From 44fbe1e701e3ce6335e3e0f8d7b2b22c1d766e0d Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Tue, 30 Jun 2020 17:38:57 -0400 Subject: [PATCH 01/12] Add initial Silicon Labs ZCL data model files. All except type_stubs.h come from https://github.com/project-chip/connectedhomeip/pull/1164 types_stub.h comes from https://github.com/project-chip/connectedhomeip/issues/1425#issuecomment-656345511 and https://github.com/project-chip/connectedhomeip/issues/1425#issuecomment-657764550 --- .../wifi-echo/server/esp32/main/af-main.h | 192 ++ .../wifi-echo/server/esp32/main/af-types.h | 1922 +++++++++++++++ examples/wifi-echo/server/esp32/main/af.h | 2061 +++++++++++++++++ .../server/esp32/main/attribute-size.c | 88 + .../server/esp32/main/attribute-storage.c | 1317 +++++++++++ .../server/esp32/main/attribute-storage.h | 267 +++ .../server/esp32/main/attribute-table.c | 826 +++++++ .../server/esp32/main/attribute-table.h | 99 + .../wifi-echo/server/esp32/main/client-api.h | 195 ++ examples/wifi-echo/server/esp32/main/common.h | 57 + examples/wifi-echo/server/esp32/main/config.h | 297 +++ .../wifi-echo/server/esp32/main/message.c | 269 +++ examples/wifi-echo/server/esp32/main/on-off.c | 301 +++ .../esp32/main/process-cluster-message.c | 113 + .../esp32/main/process-global-message.c | 755 ++++++ .../wifi-echo/server/esp32/main/time-util.h | 163 ++ .../wifi-echo/server/esp32/main/types_stub.h | 1945 ++++++++++++++++ examples/wifi-echo/server/esp32/main/util.c | 1361 +++++++++++ examples/wifi-echo/server/esp32/main/util.h | 320 +++ 19 files changed, 12548 insertions(+) create mode 100644 examples/wifi-echo/server/esp32/main/af-main.h create mode 100644 examples/wifi-echo/server/esp32/main/af-types.h create mode 100644 examples/wifi-echo/server/esp32/main/af.h create mode 100644 examples/wifi-echo/server/esp32/main/attribute-size.c create mode 100644 examples/wifi-echo/server/esp32/main/attribute-storage.c create mode 100644 examples/wifi-echo/server/esp32/main/attribute-storage.h create mode 100644 examples/wifi-echo/server/esp32/main/attribute-table.c create mode 100644 examples/wifi-echo/server/esp32/main/attribute-table.h create mode 100644 examples/wifi-echo/server/esp32/main/client-api.h create mode 100644 examples/wifi-echo/server/esp32/main/common.h create mode 100644 examples/wifi-echo/server/esp32/main/config.h create mode 100644 examples/wifi-echo/server/esp32/main/message.c create mode 100644 examples/wifi-echo/server/esp32/main/on-off.c create mode 100644 examples/wifi-echo/server/esp32/main/process-cluster-message.c create mode 100644 examples/wifi-echo/server/esp32/main/process-global-message.c create mode 100644 examples/wifi-echo/server/esp32/main/time-util.h create mode 100644 examples/wifi-echo/server/esp32/main/types_stub.h create mode 100644 examples/wifi-echo/server/esp32/main/util.c create mode 100644 examples/wifi-echo/server/esp32/main/util.h diff --git a/examples/wifi-echo/server/esp32/main/af-main.h b/examples/wifi-echo/server/esp32/main/af-main.h new file mode 100644 index 00000000000000..63023be4a400eb --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af-main.h @@ -0,0 +1,192 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief + ******************************************************************************* + ******************************************************************************/ + +#ifndef SILABS_AF_MAIN_H +#define SILABS_AF_MAIN_H + +#include CONFIGURATION_HEADER +#include PLATFORM_HEADER // Micro and compiler specific typedefs and macros +#include "stack/include/ember-types.h" + +#define MFG_STRING_MAX_LENGTH 16 + +typedef struct { + EmberAfMessageSentFunction callback; + uint8_t tag; +} CallbackTableEntry; + +#if defined(EZSP_HOST) +bool emberAfMemoryByteCompare(const uint8_t* pointer, uint8_t count, uint8_t byteValue); +#else +bool emMemoryByteCompare(const uint8_t *bytes, uint8_t count, uint8_t target); + +#define emberAfMemoryByteCompare(pointer, count, byteValue) \ + emMemoryByteCompare((pointer), (count), (byteValue)) +#endif + +// returnData must be MFG_STRING_MAX_LENGTH in length and +// is NOT expected to be NULL terminated (could be though) +void emberAfGetMfgString(uint8_t* returnData); + +// Functions common to both SOC and Host versions of the application. +void emAfInitializeMessageSentCallbackArray(void); + +EmberAfCbkeKeyEstablishmentSuite emberAfIsFullSmartEnergySecurityPresent(void); + +#if defined(EZSP_HOST) +void emAfClearNetworkCache(uint8_t networkIndex); +#else + #define emAfClearNetworkCache(index) +uint8_t emAfCopyMessageIntoRamBuffer(EmberMessageBuffer message, + uint8_t *buffer, + uint16_t bufLen); +#endif + +#if defined EZSP_HOST +// utility for setting an EZSP config value and printing the result +EzspStatus emberAfSetEzspConfigValue(EzspConfigId configId, + uint16_t value, + const char * configIdName); + +// utility for setting an EZSP policy and printing the result +EzspStatus emberAfSetEzspPolicy(EzspPolicyId policyId, + EzspDecisionId decisionId, + const char * policyName, + const char * decisionName); + +// utility for setting an EZSP value and printing the result +EzspStatus emberAfSetEzspValue(EzspValueId valueId, + uint8_t valueLength, + uint8_t *value, + const char * valueName); + +bool emberAfNcpNeedsReset(void); + +#endif // EZSP_HOST + +void emAfPrintStatus(const char * task, + EmberStatus status); + +uint8_t emberAfGetSecurityLevel(void); +uint8_t emberAfGetKeyTableSize(void); +uint8_t emberAfGetBindingTableSize(void); +uint8_t emberAfGetAddressTableSize(void); +uint8_t emberAfGetChildTableSize(void); +uint8_t emberAfGetRouteTableSize(void); +uint8_t emberAfGetNeighborTableSize(void); +uint8_t emberAfGetStackProfile(void); +uint8_t emberAfGetSleepyMulticastConfig(void); + +uint8_t emAfGetPacketBufferFreeCount(void); +uint8_t emAfGetPacketBufferTotalCount(void); + +EmberStatus emberAfGetSourceRouteTableEntry( + uint8_t index, + EmberNodeId *destination, + uint8_t *closerIndex); + +uint8_t emberAfGetSourceRouteTableTotalSize(void); +uint8_t emberAfGetSourceRouteTableFilledSize(void); + +EmberStatus emberAfGetChildData(uint8_t index, + EmberChildData* childData); + +void emAfCliVersionCommand(void); + +EmberStatus emAfPermitJoin(uint8_t duration, + bool broadcastMgmtPermitJoin); +void emAfStopSmartEnergyStartup(void); + +bool emAfProcessZdo(EmberNodeId sender, + EmberApsFrame* apsFrame, + uint8_t* message, + uint16_t length); + +void emAfIncomingMessageHandler(EmberIncomingMessageType type, + EmberApsFrame *apsFrame, + uint8_t lastHopLqi, + int8_t lastHopRssi, + uint16_t messageLength, + uint8_t *messageContents); +EmberStatus emAfSend(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint8_t messageLength, + uint8_t *message, + uint8_t *messageTag, + EmberNodeId alias, + uint8_t sequence); +void emAfMessageSentHandler(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + EmberStatus status, + uint16_t messageLength, + uint8_t *messageContents, + uint8_t messageTag); + +void emAfStackStatusHandler(EmberStatus status); +void emAfNetworkInit(void); + +// For testing purposes only, we suppress the normal call to emberNetworkInit() +// at reboot. This allows us to call it manually later and prevent the node +// from immediately coming back up on the network after reboot. +#ifdef EMBER_AF_TC_SWAP_OUT_TEST + #define EM_AF_NETWORK_INIT() +#else + #define EM_AF_NETWORK_INIT() emAfNetworkInit() +#endif + +#define emberAfCopyBigEndianEui64Argument emberCopyBigEndianEui64Argument +void emAfScheduleFindAndRejoinEvent(void); + +extern const EmberEUI64 emberAfNullEui64; + +void emberAfFormatMfgString(uint8_t* mfgString); + +extern bool emberAfPrintReceivedMessages; + +void emAfParseAndPrintVersion(EmberVersion versionStruct); +void emAfPrintEzspEndpointFlags(uint8_t endpoint); + +// Old names +#define emberAfMoveInProgress() emberAfMoveInProgressCallback() +#define emberAfStartMove() emberAfStartMoveCallback() +#define emberAfStopMove() emberAfStopMoveCallback() + +#endif // SILABS_AF_MAIN_H diff --git a/examples/wifi-echo/server/esp32/main/af-types.h b/examples/wifi-echo/server/esp32/main/af-types.h new file mode 100644 index 00000000000000..4a05032d3d4cf3 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af-types.h @@ -0,0 +1,1922 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief The include file for all the types for Ember ApplicationFramework + ******************************************************************************* + ******************************************************************************/ + +/** @addtogroup aftypes Zigbee Application Framework Types Reference + * This documentation describes the types used by the Zigbee + * Application Framework. + * @{ + */ + +#ifndef SILABS_AF_API_TYPES +#define SILABS_AF_API_TYPES + +#include "enums.h" + +#ifdef EZSP_HOST +#include "app/util/ezsp/ezsp-enum.h" +#endif + +/** + * @brief Type for referring to zigbee application profile id + */ +typedef uint16_t EmberAfProfileId; + +/** + * @brief Type for referring to ZCL attribute id + */ +typedef uint16_t EmberAfAttributeId; + +/** + * @brief Type for referring to ZCL cluster id + */ +typedef uint16_t EmberAfClusterId; + +/** + * @brief Type for referring to ZCL attribute type + */ +typedef uint8_t EmberAfAttributeType; + +/** + * @brief Type for the cluster mask + */ +typedef uint8_t EmberAfClusterMask; + +/** + * @brief Type for the attribute mask + */ +typedef uint8_t EmberAfAttributeMask; + +/** + * @brief Generic function type, used for either of the cluster function. + * + * This type is used for the array of the cluster functions, and should + * always be cast into one of the specific functions before being called. + */ +typedef void (*EmberAfGenericClusterFunction)(void); + +/** + * @brief A distinguished manufacturer code that is used to indicate the + * absence of a manufacturer-specific profile, cluster, command, or attribute. + */ +#define EMBER_AF_NULL_MANUFACTURER_CODE 0x0000 + +/** + * @brief An invalid profile ID + * This is a reserved profileId. + */ + #define EMBER_AF_INVALID_PROFILE_ID 0xFFFF + +/** + * @brief Type for default values. + * + * Default value is either a value itself, if it is 2 bytes or less, + * or a pointer to the value itself, if attribute type is longer than + * 2 bytes. + */ +typedef union { + /** + * Points to data if size is more than 2 bytes. + * If size is more than 2 bytes, and this value is NULL, + * then the default value is all zeroes. + */ + uint8_t *ptrToDefaultValue; + /** + * Actual default value if the attribute size is 2 bytes or less. + */ + uint16_t defaultValue; +} EmberAfDefaultAttributeValue; + +/** + * @brief Type describing the attribute default, min and max values. + * + * This struct is required if the attribute mask specifies that this + * attribute has a known min and max values. + */ +typedef struct { + /** + * Default value of the attribute. + */ + EmberAfDefaultAttributeValue defaultValue; + /** + * Minimum allowed value + */ + EmberAfDefaultAttributeValue minValue; + /** + * Maximum allowed value. + */ + EmberAfDefaultAttributeValue maxValue; +} EmberAfAttributeMinMaxValue; + +/** + * @brief Union describing the attribute default/min/max values. + */ +typedef union { + /** + * Points to data if size is more than 2 bytes. + * If size is more than 2 bytes, and this value is NULL, + * then the default value is all zeroes. + */ + uint8_t *ptrToDefaultValue; + /** + * Actual default value if the attribute size is 2 bytes or less. + */ + uint16_t defaultValue; + /** + * Points to the min max attribute value structure, if min/max is + * supported for this attribute. + */ + EmberAfAttributeMinMaxValue *ptrToMinMaxValue; +} EmberAfDefaultOrMinMaxAttributeValue; + +/** + * @brief Each attribute has it's metadata stored in such struct. + * + * There is only one of these per attribute across all endpoints. + */ +typedef struct { + /** + * Attribute ID, according to ZCL specs. + */ + EmberAfAttributeId attributeId; + /** + * Attribute type, according to ZCL specs. + */ + EmberAfAttributeType attributeType; + /** + * Size of this attribute in bytes. + */ + uint8_t size; + /** + * Attribute mask, tagging attribute with specific + * functionality. See ATTRIBUTE_MASK_ macros defined + * in att-storage.h. + */ + EmberAfAttributeMask mask; + /** + * Pointer to the default value union. Actual value stored + * depends on the mask. + */ + EmberAfDefaultOrMinMaxAttributeValue defaultValue; +} EmberAfAttributeMetadata; + +/** + * @brief Struct describing cluster + */ +typedef struct { + /** + * ID of cluster according to ZCL spec + */ + EmberAfClusterId clusterId; + /** + * Pointer to attribute metadata array for this cluster. + */ + EmberAfAttributeMetadata *attributes; + /** + * Total number of attributes + */ + uint16_t attributeCount; + /** + * Total size of non-external, non-singleton attribute for this cluster. + */ + uint16_t clusterSize; + /** + * Mask with additional functionality for cluster. See CLUSTER_MASK + * macros. + */ + EmberAfClusterMask mask; + + /** + * An array into the cluster functions. The length of the array + * is determined by the function bits in mask. This may be null + * if this cluster has no functions. + */ + const EmberAfGenericClusterFunction *functions; +} EmberAfCluster; + +/** + * @brief Struct used to find an attribute in storage. Together the elements + * in this search record constitute the "primary key" used to identify a unique + * attribute value in attribute storage. + */ +typedef struct { + /** + * Endpoint that the attribute is located on + */ + uint8_t endpoint; + + /** + * Cluster that the attribute is located on. If the cluster + * id is inside the manufacturer specific range, 0xfc00 - 0xffff, + * The manufacturer code should also be set to the code associated + * with the manufacturer specific cluster. + */ + EmberAfClusterId clusterId; + + /** + * Cluster mask for the cluster, used to determine if it is + * the server or client version of the cluster. See CLUSTER_MASK_ + * macros defined in att-storage.h + */ + EmberAfClusterMask clusterMask; + + /** + * The two byte identifier for the attribute. If the cluster id is + * inside the manufacturer specific range 0xfc00 - 0xffff, or the manufacturer + * code is NOT 0, the attribute is assumed to be manufacturer specific. + */ + EmberAfAttributeId attributeId; + + /** + * Manufacturer Code associated with the cluster and or attribute. + * If the cluster id is inside the manufacturer specific + * range, this value should indicate the manufacturer code for the + * manufacturer specific cluster. Otherwise if this value is non zero, + * and the cluster id is a standard ZCL cluster, + * it is assumed that the attribute being sought is a manufacturer specific + * extension to the standard ZCL cluster indicated by the cluster id. + */ + uint16_t manufacturerCode; +} EmberAfAttributeSearchRecord; + +/** + * A struct used to construct a table of manufacturer codes for + * manufacturer specific attributes and clusters. + */ +typedef struct { + uint16_t index; + uint16_t manufacturerCode; +} EmberAfManufacturerCodeEntry; + +/** + * This type is used to compare two ZCL attribute values. The size of this data + * type depends on the platform. + */ +#ifdef HAL_HAS_INT64 +typedef uint64_t EmberAfDifferenceType; +#else +typedef uint32_t EmberAfDifferenceType; +#endif + +/** + * @brief a struct containing the superset of values + * passed to both emberIncomingMessageHandler on the SOC and + * ezspIncomingMessageHandler on the host. + */ +typedef struct { + /** + * The type of the incoming message + */ + EmberIncomingMessageType type; + /** + * APS frame for the incoming message + */ + EmberApsFrame* apsFrame; + /** + * The message copied into a flat buffer + */ + uint8_t* message; + /** + * Length of the incoming message + */ + uint16_t msgLen; + /** + * Two byte node id of the sending node. + */ + uint16_t source; + /** + * Link quality from the node that last relayed + * the message. + */ + uint8_t lastHopLqi; + /** + * The energy level (in units of dBm) observed during the reception. + */ + int8_t lastHopRssi; + /** + * The index of a binding that matches the message + * or 0xFF if there is no matching binding. + */ + uint8_t bindingTableIndex; + /** + * The index of the entry in the address table + * that matches the sender of the message or 0xFF + * if there is no matching entry. + */ + uint8_t addressTableIndex; + /** + * The index of the network on which this message was received. + */ + uint8_t networkIndex; +} EmberAfIncomingMessage; + +/** + * @brief Interpan Message type: unicast, broadcast, or multicast. + */ +typedef uint8_t EmberAfInterpanMessageType; +#define EMBER_AF_INTER_PAN_UNICAST 0x00 +#define EMBER_AF_INTER_PAN_BROADCAST 0x08 +#define EMBER_AF_INTER_PAN_MULTICAST 0x0C + +// Legacy names +#define INTER_PAN_UNICAST EMBER_AF_INTER_PAN_UNICAST +#define INTER_PAN_BROADCAST EMBER_AF_INTER_PAN_BROADCAST +#define INTER_PAN_MULTICAST EMBER_AF_INTER_PAN_MULTICAST + +#define EMBER_AF_INTERPAN_OPTION_NONE 0x0000 +#define EMBER_AF_INTERPAN_OPTION_APS_ENCRYPT 0x0001 +#define EMBER_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS 0x0002 + +/** + * @brief The options for sending/receiving interpan messages. + */ +typedef uint16_t EmberAfInterpanOptions; + +/** + * @brief Interpan header used for sending and receiving interpan + * messages. + */ +typedef struct { + EmberAfInterpanMessageType messageType; + + /** + * MAC addressing + * For outgoing messages this is the destination. For incoming messages + * it is the source, which always has a long address. + */ + EmberEUI64 longAddress; + EmberNodeId shortAddress; + EmberPanId panId; + + /** + * APS data + */ + EmberAfProfileId profileId; + EmberAfClusterId clusterId; + /** + * The groupId is only used for + * EMBER_AF_INTERPAN_MULTICAST + */ + EmberMulticastId groupId; + EmberAfInterpanOptions options; +} EmberAfInterpanHeader; + +// Legacy Name +#define InterPanHeader EmberAfInterpanHeader + +/** + * @brief The options for what interpan messages are allowed. + */ +typedef uint8_t EmberAfAllowedInterpanOptions; + +#define EMBER_AF_INTERPAN_DIRECTION_CLIENT_TO_SERVER 0x01 +#define EMBER_AF_INTERPAN_DIRECTION_SERVER_TO_CLIENT 0x02 +#define EMBER_AF_INTERPAN_DIRECTION_BOTH 0x03 +#define EMBER_AF_INTERPAN_GLOBAL_COMMAND 0x04 +#define EMBER_AF_INTERPAN_MANUFACTURER_SPECIFIC 0x08 + +/** + * @brief This structure is used define an interpan message that + * will be accepted by the interpan filters. + */ +typedef struct { + EmberAfProfileId profileId; + EmberAfClusterId clusterId; + uint8_t commandId; + EmberAfAllowedInterpanOptions options; +} EmberAfAllowedInterPanMessage; + +/** + * @brief The EmberAFClusterCommand is a struct wrapper + * for all the data pertaining to a command which comes + * in over the air. This enables struct is used to + * encapsulate a command in a single place on the stack + * and pass a pointer to that location around during + * command processing + */ +typedef struct { + /** + * APS frame for the incoming message + */ + EmberApsFrame *apsFrame; + EmberIncomingMessageType type; + EmberNodeId source; + uint8_t *buffer; + uint16_t bufLen; + bool clusterSpecific; + bool mfgSpecific; + uint16_t mfgCode; + uint8_t seqNum; + uint8_t commandId; + uint8_t payloadStartIndex; + uint8_t direction; + EmberAfInterpanHeader *interPanHeader; + uint8_t networkIndex; +} EmberAfClusterCommand; + +/** + * @brief Endpoint type struct describes clusters that are on the endpoint. + */ +typedef struct { + /** + * Pointer to the cluster structs, describing clusters on this + * endpoint type. + */ + EmberAfCluster *cluster; + /** + * Number of clusters in this endpoint type. + */ + uint8_t clusterCount; + /** + * Size of all non-external, non-singlet attribute in this endpoint type. + */ + uint16_t endpointSize; +} EmberAfEndpointType; + +#ifdef EZSP_HOST +typedef EzspDecisionId EmberAfTcLinkKeyRequestPolicy; +typedef EzspDecisionId EmberAfAppLinkKeyRequestPolicy; + #define EMBER_AF_ALLOW_TC_KEY_REQUESTS EZSP_ALLOW_TC_KEY_REQUESTS_AND_SEND_CURRENT_KEY + #define EMBER_AF_DENY_TC_KEY_REQUESTS EZSP_DENY_TC_KEY_REQUESTS + #define EMBER_AF_ALLOW_APP_KEY_REQUESTS EZSP_ALLOW_APP_KEY_REQUESTS + #define EMBER_AF_DENY_APP_KEY_REQUESTS EZSP_DENY_APP_KEY_REQUESTS +#else +typedef EmberTcLinkKeyRequestPolicy EmberAfTcLinkKeyRequestPolicy; +typedef EmberAppLinkKeyRequestPolicy EmberAfAppLinkKeyRequestPolicy; + #define EMBER_AF_ALLOW_TC_KEY_REQUESTS EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY + #define EMBER_AF_DENY_TC_KEY_REQUESTS EMBER_DENY_TC_LINK_KEY_REQUESTS + #define EMBER_AF_ALLOW_APP_KEY_REQUESTS EMBER_ALLOW_APP_LINK_KEY_REQUEST + #define EMBER_AF_DENY_APP_KEY_REQUESTS EMBER_DENY_APP_LINK_KEY_REQUESTS +#endif + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfSecurityProfile +#else +typedef uint8_t EmberAfSecurityProfile; +enum +#endif +{ + EMBER_AF_SECURITY_PROFILE_NONE = 0x00, + EMBER_AF_SECURITY_PROFILE_HA = 0x01, + EMBER_AF_SECURITY_PROFILE_HA12 = 0x02, + EMBER_AF_SECURITY_PROFILE_SE_TEST = 0x03, + EMBER_AF_SECURITY_PROFILE_SE_FULL = 0x04, + EMBER_AF_SECURITY_PROFILE_Z3 = 0x05, + EMBER_AF_SECURITY_PROFILE_CUSTOM = 0xFF, +}; + +typedef struct { + EmberAfSecurityProfile securityProfile; + uint16_t tcBitmask; + EmberExtendedSecurityBitmask tcExtendedBitmask; + uint16_t nodeBitmask; + EmberExtendedSecurityBitmask nodeExtendedBitmask; + EmberAfTcLinkKeyRequestPolicy tcLinkKeyRequestPolicy; + EmberAfAppLinkKeyRequestPolicy appLinkKeyRequestPolicy; + EmberKeyData preconfiguredKey; +} EmberAfSecurityProfileData; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +typedef struct { + EmberNodeType nodeType; + EmberAfSecurityProfile securityProfile; +} EmAfZigbeeProNetwork; + +#endif + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfEndpointBitmask; +#else +typedef uint8_t EmberAfEndpointBitmask; +enum +#endif +{ + EMBER_AF_ENDPOINT_DISABLED = 0x00, + EMBER_AF_ENDPOINT_ENABLED = 0x01, +}; + +/** + * @brief Struct that maps actual endpoint type, onto a specific endpoint. + */ +typedef struct { + /** + * Actual zigbee endpoint number. + */ + uint8_t endpoint; + /** + * Profile ID of the device on this endpoint. + */ + EmberAfProfileId profileId; + /** + * Device ID of the device on this endpoint. + */ + uint16_t deviceId; + /** + * Version of the device. + */ + uint8_t deviceVersion; + /** + * Endpoint type for this endpoint. + */ + EmberAfEndpointType *endpointType; + /** + * Network index for this endpoint. + */ + uint8_t networkIndex; + /** + * Meta-data about the endpoint + */ + EmberAfEndpointBitmask bitmask; +} EmberAfDefinedEndpoint; + +// Cluster specific types + +/** + * @brief Bitmask data type for storing one bit of information for each ESI in + * the ESI table. + */ +#if (EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 8) +typedef uint8_t EmberAfPluginEsiManagementBitmask; +#elif (EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 16) +typedef uint16_t EmberAfPluginEsiManagementBitmask; +#elif (EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 32) +typedef uint32_t EmberAfPluginEsiManagementBitmask; +#else + #error "EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE cannot exceed 32" +#endif + +/** + * @brief Struct that describes a load control event. + * + * This is used in the load control event callback and + * within the demand response load control cluster code. + */ +typedef struct { + uint32_t eventId; +#ifdef EMBER_AF_PLUGIN_DRLC_SERVER + EmberEUI64 source; + uint8_t sourceEndpoint; +#endif //EMBER_AF_PLUGIN_DRLC_SERVER + +#ifdef EMBER_AF_PLUGIN_DRLC + EmberAfPluginEsiManagementBitmask esiBitmask; +#endif //EMBER_AF_PLUGIN_DRLC + + uint8_t destinationEndpoint; + uint16_t deviceClass; + uint8_t utilityEnrollmentGroup; + /** + * Start time in seconds + */ + uint32_t startTime; + /** + * Duration in minutes + */ + uint16_t duration; + uint8_t criticalityLevel; + uint8_t coolingTempOffset; + uint8_t heatingTempOffset; + int16_t coolingTempSetPoint; + int16_t heatingTempSetPoint; + int8_t avgLoadPercentage; + uint8_t dutyCycle; + uint8_t eventControl; + uint32_t startRand; + uint32_t durationRand; + uint8_t optionControl; +} EmberAfLoadControlEvent; + +/** + * @brief This is an enum used to indicate the result of the + * service discovery. Unicast discoveries are completed + * as soon as a response is received. Broadcast discoveries + * wait a period of time for multiple responses to be received. + */ +typedef enum { + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE = 0x00, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_RESPONSE_RECEIVED = 0x01, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_TIMEOUT = 0x02, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x03, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x04, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x05, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x06, +} EmberAfServiceDiscoveryStatus; + +#define EM_AF_DISCOVERY_RESPONSE_MASK (0x05) + +/** + * @brief A simple way to determine if the service discovery callback + * has a response. + */ +#define emberAfHaveDiscoveryResponseStatus(status) ((status) & EM_AF_DISCOVERY_RESPONSE_MASK) + +/** + * @brief A structure containing general information about the service discovery. + */ +typedef struct { + /** + * The status indicates both the type of request (broadcast or unicast) + * and whether a response has been received. + */ + EmberAfServiceDiscoveryStatus status; + + /** + * This indicates what ZDO request cluster was associated with the request. + * It is helpful for a callback that may be used for multiple ZDO request types + * to determine the type of data returned. This will be based on the + * ZDO cluster values defined in ember-types.h. + */ + uint16_t zdoRequestClusterId; + + /** + * This is the address of the device that matched the request, which may + * be different than the device that *actually* is responding. This occurs + * when parents respond on behalf of their children. + */ + EmberNodeId matchAddress; + + /** + * Only if the status code indicates a response will this data be non-NULL. + * When there is data, the type is according to the ZDO cluster ID sent out. + * For NETWORK_ADDRESS_REQUEST or IEEE_ADDRESS_REQUEST, the long ID will + * be contained in the responseData, so it will be a value of type ::EmberEUI64. + * The short ID will be in the matchAddress parameter field. + * For the MATCH_DESCRIPTORS_REQUEST the responseData will point + * to an ::EmberAfEndpointList structure. + */ + const void* responseData; +} EmberAfServiceDiscoveryResult; + +/** + * @brief A list of endpoints received during a service discovery attempt. + * This will be returned for a match descriptor request and a + * active endpoint request. + */ +typedef struct { + uint8_t count; + const uint8_t* list; +} EmberAfEndpointList; + +/** + * @brief A list of clusters received during a service discovery attempt. + * This will be returned for a simple descriptor request. + */ +typedef struct { + uint8_t inClusterCount; + const uint16_t* inClusterList; + uint8_t outClusterCount; + const uint16_t* outClusterList; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; +} EmberAfClusterList; + +/** + * @brief This defines a callback where a code element or cluster can be informed + * as to the result of a service discovery they have requested. + * For each match, the callback is fired with all the resulting matches from + * that source. If the discovery was unicast to a specific device, then + * the callback will only be fired once with either MATCH_FOUND or COMPLETE + * (no matches found). If the discovery is broadcast then multiple callbacks + * may be fired with ::EMBER_AF_SERVICE_DISCOVERY_RESPONSE_RECEIVED. + * After a couple seconds the callback will then be fired with + * ::EMBER_AF_SERVICE_DISCOVERY_COMPLETE as the result. + */ +typedef void (EmberAfServiceDiscoveryCallback)(const EmberAfServiceDiscoveryResult* result); + +/** + * @brief This defines a callback where a code element or cluster can be + * informed as to the result of a request to initiate a partner link key + * exchange. The callback will be triggered with success equal to true if the + * exchange completed successfully. + */ +typedef void (EmberAfPartnerLinkKeyExchangeCallback)(bool success); + +/** + * @brief This is an enum used to control how the device will poll for a given + * active cluster-related event. When the event is scheduled, the application + * can pass a poll control value which will be stored along with the event. + * The processor is only allowed to poll according to the most restrictive + * value for all active event. For instance, if two events are active, one + * with EMBER_AF_LONG_POLL and the other with EMBER_AF_SHORT_POLL, then the + * processor will short poll until the second event is deactivated. + */ +typedef enum { + EMBER_AF_LONG_POLL, + EMBER_AF_SHORT_POLL, +} EmberAfEventPollControl; + +/** + * @brief This is an enum used to control how the device + * will sleep for a given active cluster related event. + * When the event is scheduled, the scheduling code can + * pass a sleep control value which will be stored along + * with the event. The processor is only allowed to sleep + * according to the most restrictive sleep control value + * for any active event. For instance, if two events + * are active, one with EMBER_AF_OK_TO_HIBERNATE and the + * other with EMBER_AF_OK_TO_NAP, then the processor + * will only be allowed to nap until the second event + * is deactivated. + */ +typedef enum { + EMBER_AF_OK_TO_SLEEP, + /** @deprecated. */ + EMBER_AF_OK_TO_HIBERNATE = EMBER_AF_OK_TO_SLEEP, + /** @deprecated. */ + EMBER_AF_OK_TO_NAP, + EMBER_AF_STAY_AWAKE, +} EmberAfEventSleepControl; + +/** + * @brief An enum used to track the tasks that the Application + * framework cares about. These are intended to be tasks + * that should keep the device out of hibernation like an + * application level request / response. If the response does + * not come in as a data ack, then the application will need + * to stay out of hibernation to wait and poll for it. + * + * Of course some tasks do not necessarily have a response. For + * instance, a ZDO request may or may not have a response. In this + * case, the application framework cannot rely on the fact that + * a response will come in to end the wake cycle, so the Application + * framework must timeout the wake cycle if no expected + * response is received or no other event can be relied upon to + * end the wake cycle. + * + * Tasks of this type should be added to the wake timeout mask + * by calling ::emberAfSetWakeTimeoutBitmaskCallback so that they + * can be governed by a timeout instead of a request / response + * + * the current tasks bitmask is an uint32_t bitmask used to + * track which tasks are active at any given time. The bottom 16 bits, + * values 0x01 - 0x8000 are reserved for Ember's use. The top + * 16 bits are reserved for the customer, values 0x10000 - + * 0x80000000 + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfApplicationTask +#else +typedef uint32_t EmberAfApplicationTask; +enum +#endif +{ + // we may be able to remove these top two since they are + // handled by the stack on the SOC. + EMBER_AF_WAITING_FOR_DATA_ACK = 0x00000001, //not needed? + EMBER_AF_LAST_POLL_GOT_DATA = 0x00000002, //not needed? + EMBER_AF_WAITING_FOR_SERVICE_DISCOVERY = 0x00000004, + EMBER_AF_WAITING_FOR_ZDO_RESPONSE = 0x00000008, + EMBER_AF_WAITING_FOR_ZCL_RESPONSE = 0x00000010, + EMBER_AF_WAITING_FOR_REGISTRATION = 0x00000020, + EMBER_AF_WAITING_FOR_PARTNER_LINK_KEY_EXCHANGE = 0x00000040, + EMBER_AF_FORCE_SHORT_POLL = 0x00000080, + EMBER_AF_FRAGMENTATION_IN_PROGRESS = 0x00000100, + EMBER_AF_FORCE_SHORT_POLL_FOR_PARENT_CONNECTIVITY = 0x00000200, +}; + +/** + * @brief a structure used to keep track of cluster related events and + * their sleep control values. The cluster code will not know at + * runtime all of the events that it has access to in the event table + * This structure is stored by the application framework in an event + * context table which along with helper functions allows the cluster + * code to schedule and deactivate its associated events. + */ +typedef struct { + /** + * The endpoint of the associated cluster event. + */ + uint8_t endpoint; + /** + * The cluster id of the associated cluster event. + */ + EmberAfClusterId clusterId; + /** + * The server/client identity of the associated cluster event. + */ + bool isClient; + /** + * A poll control value used to control the network polling behavior while + * the event is active. + */ + EmberAfEventPollControl pollControl; + /** + * A sleep control value used to control the processor's sleep + * behavior while the event is active. + */ + EmberAfEventSleepControl sleepControl; + /** + * A pointer to the event control value which is stored in the event table + * and is used to actually schedule the event. + */ + EmberEventControl *eventControl; +} EmberAfEventContext; + +/** + * @brief Type for referring to the handler for network events. + */ +typedef void (*EmberAfNetworkEventHandler)(void); + +/** + * @brief Type for referring to the handler for endpoint events. + */ +typedef void (*EmberAfEndpointEventHandler)(uint8_t endpoint); + +#ifdef EMBER_AF_PLUGIN_GROUPS_SERVER +/** + * @brief Indicates the absence of a Group table entry. + */ +#define EMBER_AF_GROUP_TABLE_NULL_INDEX 0xFF +/** + * @brief Value used when setting or getting the endpoint in a Group table + * entry. It indicates that the entry is not in use. + */ +#define EMBER_AF_GROUP_TABLE_UNUSED_ENDPOINT_ID 0x00 +/** + * @brief Maximum length of Group names, not including the length byte. + */ +#define ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH 16 +/** + * @brief A structure used to store group table entries in RAM or in tokens, + * depending on the platform. If the endpoint field is + * ::EMBER_AF_GROUP_TABLE_UNUSED_ENDPOINT_ID, the entry is unused. + */ +typedef struct { + uint8_t endpoint; // 0x00 when not in use + uint16_t groupId; + uint8_t bindingIndex; +#ifdef EMBER_AF_PLUGIN_GROUPS_SERVER_NAME_SUPPORT + uint8_t name[ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; +#endif +} EmberAfGroupTableEntry; +#endif //EMBER_AF_PLUGIN_GROUPS_SERVER + +/** + * @brief Indicates the absence of a Scene table entry. + */ +#define EMBER_AF_SCENE_TABLE_NULL_INDEX 0xFF +/** + * @brief Value used when setting or getting the endpoint in a Scene table + * entry. It indicates that the entry is not in use. + */ +#define EMBER_AF_SCENE_TABLE_UNUSED_ENDPOINT_ID 0x00 +/** + * @brief Maximum length of Scene names, not including the length byte. + */ +#define ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH 16 +/** + * @brief The group identifier for the global scene. + */ +#define ZCL_SCENES_GLOBAL_SCENE_GROUP_ID 0x0000 +/** + * @brief The scene identifier for the global scene. + */ +#define ZCL_SCENES_GLOBAL_SCENE_SCENE_ID 0x00 +/** + * @brief A structure used to store scene table entries in RAM or in tokens, + * depending on a plugin setting. If endpoint field is + * ::EMBER_AF_SCENE_TABLE_UNUSED_ENDPOINT_ID, the entry is unused. + */ +typedef struct { + uint8_t endpoint; // 0x00 when this record is not in use + uint16_t groupId; // 0x0000 if not associated with a group + uint8_t sceneId; +#ifdef EMBER_AF_PLUGIN_SCENES_NAME_SUPPORT + uint8_t name[ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; +#endif + uint16_t transitionTime; // in seconds + uint8_t transitionTime100ms; // in tenths of a seconds +#ifdef ZCL_USING_ON_OFF_CLUSTER_SERVER + bool hasOnOffValue; + bool onOffValue; +#endif +#ifdef ZCL_USING_LEVEL_CONTROL_CLUSTER_SERVER + bool hasCurrentLevelValue; + uint8_t currentLevelValue; +#endif +#ifdef ZCL_USING_THERMOSTAT_CLUSTER_SERVER + bool hasOccupiedCoolingSetpointValue; + int16_t occupiedCoolingSetpointValue; + bool hasOccupiedHeatingSetpointValue; + int16_t occupiedHeatingSetpointValue; + bool hasSystemModeValue; + uint8_t systemModeValue; +#endif +#ifdef ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER + bool hasCurrentXValue; + uint16_t currentXValue; + bool hasCurrentYValue; + uint16_t currentYValue; + bool hasEnhancedCurrentHueValue; + uint16_t enhancedCurrentHueValue; + bool hasCurrentSaturationValue; + uint8_t currentSaturationValue; + bool hasColorLoopActiveValue; + uint8_t colorLoopActiveValue; + bool hasColorLoopDirectionValue; + uint8_t colorLoopDirectionValue; + bool hasColorLoopTimeValue; + uint16_t colorLoopTimeValue; + bool hasColorTemperatureMiredsValue; + uint16_t colorTemperatureMiredsValue; +#endif //ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER +#ifdef ZCL_USING_DOOR_LOCK_CLUSTER_SERVER + bool hasLockStateValue; + uint8_t lockStateValue; +#endif +#ifdef ZCL_USING_WINDOW_COVERING_CLUSTER_SERVER + bool hasCurrentPositionLiftPercentageValue; + uint8_t currentPositionLiftPercentageValue; + bool hasCurrentPositionTiltPercentageValue; + uint8_t currentPositionTiltPercentageValue; +#endif +} EmberAfSceneTableEntry; + +#if !defined(EMBER_AF_PLUGIN_MESSAGING_CLIENT) +// In order to be able to forward declare callbacks regardless of whether the plugin +// is enabled, we need to define all data structures. In order to be able to define +// the messaging client data struct, we need to declare this variable. + #define EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE 0 +#endif + +typedef struct { + bool valid; + bool active; + EmberAfPluginEsiManagementBitmask esiBitmask; + uint8_t clientEndpoint; + uint32_t messageId; + uint8_t messageControl; + uint32_t startTime; + uint32_t endTime; + uint16_t durationInMinutes; + uint8_t message[EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE + 1]; +} EmberAfPluginMessagingClientMessage; + +#define ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH 11 +typedef struct { + bool valid; + bool active; + uint8_t clientEndpoint; + uint32_t providerId; + uint8_t rateLabel[ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH + 1]; + uint32_t issuerEventId; + uint32_t currentTime; + uint8_t unitOfMeasure; + uint16_t currency; + uint8_t priceTrailingDigitAndPriceTier; + uint8_t numberOfPriceTiersAndRegisterTier; + uint32_t startTime; + uint32_t endTime; + uint16_t durationInMinutes; + uint32_t price; + uint8_t priceRatio; + uint32_t generationPrice; + uint8_t generationPriceRatio; + uint32_t alternateCostDelivered; + uint8_t alternateCostUnit; + uint8_t alternateCostTrailingDigit; + uint8_t numberOfBlockThresholds; + uint8_t priceControl; +} EmberAfPluginPriceClientPrice; + +/** + * @brief Specifies CPP Authorization values + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfPluginPriceCppAuth +#else +typedef uint8_t EmberAfPluginPriceCppAuth; +enum +#endif +{ + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_PENDING = 0, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_ACCEPTED = 1, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_REJECTED = 2, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_FORCED = 3, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_RESERVED = 4 +}; + +/** + * @brief Value used when setting or getting the endpoint in a report table + * entry. It indicates that the entry is not in use. + */ +#define EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID 0x00 +/** + * @brief A structure used to store reporting configurations. If endpoint + * field is ::EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID, the entry is + * unused. + */ +typedef struct { + /** EMBER_ZCL_REPORTING_DIRECTION_REPORTED for reports sent from the local + * device or EMBER_ZCL_REPORTING_DIRECTION_RECEIVED for reports received + * from a remote device. + */ + EmberAfReportingDirection direction; + /** The local endpoint from which the attribute is reported or to which the + * report is received. If ::EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID, + * the entry is unused. + */ + uint8_t endpoint; + /** The cluster where the attribute is located. */ + EmberAfClusterId clusterId; + /** The id of the attribute being reported or received. */ + EmberAfAttributeId attributeId; + /** CLUSTER_MASK_SERVER for server-side attributes or CLUSTER_MASK_CLIENT for + * client-side attributes. + */ + uint8_t mask; + /** Manufacturer code associated with the cluster and/or attribute. If the + * cluster id is inside the manufacturer-specific range, this value + * indicates the manufacturer code for the cluster. Otherwise, if this + * value is non-zero and the cluster id is a standard ZCL cluster, it + * indicates the manufacturer code for attribute. + */ + uint16_t manufacturerCode; + union { + struct { + /** The minimum reporting interval, measured in seconds. */ + uint16_t minInterval; + /** The maximum reporting interval, measured in seconds. */ + uint16_t maxInterval; + /** The minimum change to the attribute that will result in a report + * being sent. + */ + uint32_t reportableChange; + } reported; + struct { + /** The node id of the source of the received reports. */ + EmberNodeId source; + /** The remote endpoint from which the attribute is reported. */ + uint8_t endpoint; + /** The maximum expected time between reports, measured in seconds. */ + uint16_t timeout; + } received; + } data; +} EmberAfPluginReportingEntry; + +typedef enum { + EMBER_AF_PLUGIN_TUNNELING_CLIENT_SUCCESS = 0x00, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_BUSY = 0x01, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_NO_MORE_TUNNEL_IDS = 0x02, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_PROTOCOL_NOT_SUPPORTED = 0x03, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_FLOW_CONTROL_NOT_SUPPORTED = 0x04, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_REQUEST_FAILED = 0xF9, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_NOT_FOUND = 0xFA, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_ADDRESS_TABLE_FULL = 0xFB, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_REQUEST_FAILED = 0xFC, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_FAILED = 0xFD, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_FAILED = 0xFE, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_TIMEOUT = 0xFF, +} EmberAfPluginTunnelingClientStatus; + +#ifdef EMBER_AF_PLUGIN_ZLL_COMMISSIONING_COMMON +/** + * @brief Status codes used by the ZLL Commissioning plugin. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfZllCommissioningStatus +#else +typedef uint8_t EmberAfZllCommissioningStatus; +enum +#endif +{ + EMBER_AF_ZLL_ABORTED_BY_APPLICATION = 0x00, + EMBER_AF_ZLL_CHANNEL_CHANGE_FAILED = 0x01, + EMBER_AF_ZLL_JOINING_FAILED = 0x02, + EMBER_AF_ZLL_NO_NETWORKS_FOUND = 0x03, + EMBER_AF_ZLL_PREEMPTED_BY_STACK = 0x04, + EMBER_AF_ZLL_SENDING_START_JOIN_FAILED = 0x05, + EMBER_AF_ZLL_SENDING_DEVICE_INFORMATION_REQUEST_FAILED = 0x06, + EMBER_AF_ZLL_SENDING_IDENTIFY_REQUEST_FAILED = 0x07, + EMBER_AF_ZLL_SENDING_RESET_TO_FACTORY_NEW_REQUEST_FAILED = 0x08, + EMBER_AF_ZLL_NETWORK_FORMATION_FAILED = 0x09, + EMBER_AF_ZLL_NETWORK_UPDATE_OPERATION = 0x0A, +}; + +/** + * @brief A structure used to represent Group Information Records used by ZLL + * Commissioning. + */ +typedef struct { + EmberMulticastId groupId; + uint8_t groupType; +} EmberAfPluginZllCommissioningGroupInformationRecord; + +/** + * @brief A structure used to represent Endpoint Information Records used by + * ZLL Commissioning. + */ +typedef struct { + EmberNodeId networkAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; +} EmberAfPluginZllCommissioningEndpointInformationRecord; +#endif + +/** + * @brief This is a unique identifier for referencing zigbee Over-the-air upgrade + * images. It is used by the OTA plugins when passing around information about + * an upgrade file. + */ +typedef struct { + uint16_t manufacturerId; + uint16_t imageTypeId; + uint32_t firmwareVersion; + + /** + * This is only used for device specific files. + * It will be set to all 0's when the image does not + * have an upgrade destination field in it. + * Little endian format. + */ + uint8_t deviceSpecificFileEui64[EUI64_SIZE]; +} EmberAfOtaImageId; + +/** + * @brief The list of options possible for the image block request/response. + */ +enum { + EMBER_AF_IMAGE_BLOCK_REQUEST_OPTIONS_NONE = 0x00, + // Client supports Min Block Request field + EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_CLIENT = 0x01, + // Server supports Min Block Request field + EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_SERVER = 0x02, + // The Image Block Request is actually simulated in place of an actually + // received Image Page Request + EMBER_AF_IMAGE_BLOCK_REQUEST_SIMULATED_FROM_PAGE_REQUEST = 0x04 +}; +typedef uint8_t EmberAfImageBlockRequestOptions; + +/** + * @brief This is the data structure that is passed to the + * emberAfImageBlockRequestCallback() to let the application decide what to do. + */ +typedef struct { + const EmberAfOtaImageId* id; + uint32_t offset; + uint32_t waitTimeSecondsResponse; + EmberNodeId source; + EmberEUI64 sourceEui; // optionally present in messages + // The minBlockRequestPeriod can be treated as milliseconds or seconds on the + // client. The OTA server plugin has optional support to probe clients and + // treat this field with appropriate units (ms or sec) + uint16_t minBlockRequestPeriod; // optionally present in messages + uint8_t maxDataSize; + uint8_t clientEndpoint; + EmberAfImageBlockRequestOptions bitmask; +} EmberAfImageBlockRequestCallbackStruct; + +/** + * @brief This status contains the success or error code of an OTA storage + * device operation. + */ +typedef enum { + EMBER_AF_OTA_STORAGE_SUCCESS = 0, + EMBER_AF_OTA_STORAGE_ERROR = 1, + EMBER_AF_OTA_STORAGE_RETURN_DATA_TOO_LONG = 2, + EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND = 3, + EMBER_AF_OTA_STORAGE_OPERATION_IN_PROGRESS = 4, +} EmberAfOtaStorageStatus; + +/** + * @brief This status contains the success or error code of an OTA download + * operation. + */ +enum { + EMBER_AF_OTA_DOWNLOAD_AND_VERIFY_SUCCESS = 0, + EMBER_AF_OTA_DOWNLOAD_TIME_OUT = 1, + EMBER_AF_OTA_VERIFY_FAILED = 2, + EMBER_AF_OTA_SERVER_ABORTED = 3, + EMBER_AF_OTA_CLIENT_ABORTED = 4, + EMBER_AF_OTA_ERASE_FAILED = 5, +}; +typedef uint8_t EmberAfOtaDownloadResult; + +/** + * @brief The maximum size of the string that is present in the header + * of the zigbee Over-the-air file format. + */ +#define EMBER_AF_OTA_MAX_HEADER_STRING_LENGTH 32 + +#define UID_SIZE 32 +/** + * @brief This structure is an in-memory representation of + * the Over-the-air header data that resides on disk. + * It is not a byte-for-byte copy. + */ +typedef struct { + // Magic Number omitted since it is always the same. + uint16_t headerVersion; + uint16_t headerLength; + uint16_t fieldControl; + uint16_t manufacturerId; + uint16_t imageTypeId; // a.k.a. Device ID + uint32_t firmwareVersion; + uint16_t zigbeeStackVersion; + + /** + * @brief The spec. does NOT require that the string be NULL terminated in the + * header stored on disk. Therefore we make sure we can support a + * 32-character string without a NULL terminator by adding +1 in the data + * structure. + */ + uint8_t headerString[EMBER_AF_OTA_MAX_HEADER_STRING_LENGTH + 1]; + + /** + * @brief When reading the header this will be the complete length of + * the file. When writing the header, this must be set to + * the length of the MFG image data portion including all tags. + */ + uint32_t imageSize; + + /** + * @brief The remaining four fields are optional. The field control should be checked + * to determine if their values are valid. + */ + uint8_t securityCredentials; + union { + uint8_t EUI64[EUI64_SIZE]; + uint8_t UID[UID_SIZE]; + } upgradeFileDestination; + uint16_t minimumHardwareVersion; + uint16_t maximumHardwareVersion; +} EmberAfOtaHeader; + +/** + * @brief This structure contains information about a tag that resides + * within an Over-the-air bootload file. + */ +typedef struct { + uint16_t id; + uint32_t length; +} EmberAfTagData; + +typedef enum { + NO_APP_MESSAGE = 0, + RECEIVED_PARTNER_CERTIFICATE = 1, + GENERATING_EPHEMERAL_KEYS = 2, + GENERATING_SHARED_SECRET = 3, + KEY_GENERATION_DONE = 4, + GENERATE_SHARED_SECRET_DONE = 5, + /** + * LINK_KEY_ESTABLISHED indicates Success, + * key establishment done. + */ + LINK_KEY_ESTABLISHED = 6, + + /** + * Error codes: + * Transient failures where Key Establishment could be retried + */ + NO_LOCAL_RESOURCES = 7, + PARTNER_NO_RESOURCES = 8, + TIMEOUT_OCCURRED = 9, + INVALID_APP_COMMAND = 10, + MESSAGE_SEND_FAILURE = 11, + PARTNER_SENT_TERMINATE = 12, + INVALID_PARTNER_MESSAGE = 13, + PARTNER_SENT_DEFAULT_RESPONSE_ERROR = 14, + + /** + * Fatal Errors: + * These results are not worth retrying because the outcome + * will not change + */ + BAD_CERTIFICATE_ISSUER = 15, + KEY_CONFIRM_FAILURE = 16, + BAD_KEY_ESTABLISHMENT_SUITE = 17, + + KEY_TABLE_FULL = 18, + + /** + * Neither initiator nor responder is an + * ESP/TC so the key establishment is not + * allowed per the spec. + */ + NO_ESTABLISHMENT_ALLOWED = 19, + + /* 283k1 certificates need to have valid key usage + */ + INVALID_CERTIFICATE_KEY_USAGE = 20, +} EmberAfKeyEstablishmentNotifyMessage; + +#define APP_NOTIFY_ERROR_CODE_START NO_LOCAL_RESOURCES +#define APP_NOTIFY_MESSAGE_TEXT { \ + "None", \ + "Received Cert", \ + "Generate keys", \ + "Generate secret", \ + "Key generate done", \ + "Generate secret done", \ + "Link key verified", \ + \ + /* Transient Error codes */ \ + "No local resources", \ + "Partner no resources", \ + "Timeout", \ + "Invalid app. command", \ + "Message send failure", \ + "Partner sent terminate", \ + "Bad message", \ + "Partner sent Default Rsp", \ + \ + /* Fatal errors */ \ + "Bad cert issuer", \ + "Key confirm failure", \ + "Bad key est. suite", \ + "Key table full", \ + "Not allowed", \ + "Invalid Key Usage", \ +} + +/** + * @brief This enumeration is used to indicate the state of an OTA bootload + * image undergoing verification. This is used both for cryptographic + * verification and manufacturer specific verification. + */ +typedef enum { + EMBER_AF_IMAGE_GOOD = 0, + EMBER_AF_IMAGE_BAD = 1, + EMBER_AF_IMAGE_VERIFY_IN_PROGRESS = 2, + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + // Internal use only. + EMBER_AF_IMAGE_VERIFY_WAIT = 3, + EMBER_AF_IMAGE_VERIFY_ERROR = 4, + EMBER_AF_IMAGE_UNKNOWN = 5, + EMBER_AF_NO_IMAGE_VERIFY_SUPPORT = 6, +#endif +} EmberAfImageVerifyStatus; + +/** + * @brief Type for referring to the tick callback for cluster. + * + * Tick function will be called once for each tick for each endpoint in + * the cluster. The rate of tick is determined by the metadata of the + * cluster. + */ +typedef void (*EmberAfTickFunction)(uint8_t endpoint); + +/** + * @brief Type for referring to the init callback for cluster. + * + * Init function is called when the application starts up, once for + * each cluster/endpoint combination. + */ +typedef void (*EmberAfInitFunction)(uint8_t endpoint); + +/** + * @brief Type for referring to the attribute changed callback function. + * + * This function is called just after an attribute changes. + */ +typedef void (*EmberAfClusterAttributeChangedCallback)(uint8_t endpoint, + EmberAfAttributeId attributeId); + +/** + * @brief Type for referring to the manufacturer specific + * attribute changed callback function. + * + * This function is called just after a manufacturer specific attribute changes. + */ +typedef void (*EmberAfManufacturerSpecificClusterAttributeChangedCallback)(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); + +/** + * @brief Type for referring to the pre-attribute changed callback function. + * + * This function is called before an attribute changes. + */ +typedef EmberAfStatus (*EmberAfClusterPreAttributeChangedCallback)(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); + +/** + * @brief Type for referring to the default response callback function. + * + * This function is called when default response is received, before + * the global callback. Global callback is called immediately afterwards. + */ +typedef void (*EmberAfDefaultResponseFunction)(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); + +/** + * @brief Type for referring to the message sent callback function. + * + * This function is called when a message is sent. + */ +typedef void (*EmberAfMessageSentFunction)(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); + +/** + * @brief The EmberAfMessageStruct is a struct wrapper that + * contains all the data about a low-level message to be + * sent (it may be ZCL or may be some other protocol). + */ +typedef struct { + EmberAfMessageSentFunction callback; + EmberApsFrame* apsFrame; + uint8_t* message; + uint16_t indexOrDestination; + uint16_t messageLength; + EmberOutgoingMessageType type; + bool broadcast; +} EmberAfMessageStruct; + +/** + * @brief A data struct for a link key backup. + * + * Each entry notes the EUI64 of the device it is paired to and the key data. + * This key may be hashed and not the actual link key currently in use. + */ + +typedef struct { + EmberEUI64 deviceId; + EmberKeyData key; +} EmberAfLinkKeyBackupData; + +/** + * @brief A data struct for all the trust center backup data. + * + * The 'keyList' pointer must point to an array and 'maxKeyListLength' + * must be populated with the maximum number of entries the array can hold. + * + * Functions that modify this data structure will populate 'keyListLength' + * indicating how many keys were actually written into 'keyList'. + */ + +typedef struct { + EmberEUI64 extendedPanId; + uint8_t keyListLength; + uint8_t maxKeyListLength; + EmberAfLinkKeyBackupData* keyList; +} EmberAfTrustCenterBackupData; + +/** + * @brief The length of the hardware tag in the Ember Bootloader Query + * Response. + */ +#define EMBER_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH 16 + +/** + * @brief A data struct for the information retrieved during a response + * to an Ember Bootloader over-the-air query. + */ +typedef struct { + uint8_t hardwareTag[EMBER_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH]; + uint8_t eui64[EUI64_SIZE]; + uint16_t mfgId; + uint16_t bootloaderVersion; + uint8_t capabilities; + uint8_t platform; + uint8_t micro; + uint8_t phy; + bool bootloaderActive; +} EmberAfStandaloneBootloaderQueryResponseData; + +/** + * @brief A data struct used to keep track of incoming and outgoing + * commands for command discovery + */ +typedef struct { + uint16_t clusterId; + uint8_t commandId; + uint8_t mask; +} EmberAfCommandMetadata; + +/** + * @brief A data structure used to describe the time in a human + * understandable format (as opposed to 32-bit UTC) + */ + +typedef struct { + uint16_t year; + uint8_t month; + uint8_t day; + uint8_t hours; + uint8_t minutes; + uint8_t seconds; +} EmberAfTimeStruct; + +/** + * @brief A data structure used to describe the ZCL Date data type + */ + +typedef struct { + uint8_t year; + uint8_t month; + uint8_t dayOfMonth; + uint8_t dayOfWeek; +} EmberAfDate; + +/* Simple Metering Server Test Code */ +#define EMBER_AF_PLUGIN_SIMPLE_METERING_SERVER_ELECTRIC_METER 0 +#define EMBER_AF_PLUGIN_SIMPLE_METERING_SERVER_GAS_METER 1 + +// Functional Notification Flags +// Also #defined in enums.h under slightly different names +#define EMBER_AF_METERING_FNF_NEW_OTA_FIRMWARE 0x00000001 +#define EMBER_AF_METERING_FNF_CBKE_UPDATE_REQUEST 0x00000002 +#define EMBER_AF_METERING_FNF_TIME_SYNC 0x00000004 +#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_HAN 0x00000010 +#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_WAN 0x00000020 +#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET 0x000001C0 +#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET 0x00000E00 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER 0x00001000 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_METERING_CLUSTER 0x00002000 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER 0x00004000 +#define EMBER_AF_METERING_FNF_NETWORK_KEY_ACTIVE 0x00008000 +#define EMBER_AF_METERING_FNF_DISPLAY_MESSAGE 0x00010000 +#define EMBER_AF_METERING_FNF_CANCEL_ALL_MESSAGES 0x00020000 +#define EMBER_AF_METERING_FNF_CHANGE_SUPPLY 0x00040000 +#define EMBER_AF_METERING_FNF_LOCAL_CHANGE_SUPPLY 0x00080000 +#define EMBER_AF_METERING_FNF_SET_UNCONTROLLED_FLOW_THRESHOLD 0x00100000 +#define EMBER_AF_METERING_FNF_TUNNEL_MESSAGE_PENDING 0x00200000 +#define EMBER_AF_METERING_FNF_GET_SNAPSHOT 0x00400000 +#define EMBER_AF_METERING_FNF_GET_SAMPLED_DATA 0x00800000 +#define EMBER_AF_METERING_FNF_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE 0x01000000 +#define EMBER_AF_METERING_FNF_ENERGY_SCAN_PENDING 0x02000000 +#define EMBER_AF_METERING_FNF_CHANNEL_CHANGE_PENDING 0x04000000 + +// Notification Flags 2 +#define EMBER_AF_METERING_NF2_PUBLISH_PRICE 0x00000001 +#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_PERIOD 0x00000002 +#define EMBER_AF_METERING_NF2_PUBLISH_TARIFF_INFORMATION 0x00000004 +#define EMBER_AF_METERING_NF2_PUBLISH_CONVERSION_FACTOR 0x00000008 +#define EMBER_AF_METERING_NF2_PUBLISH_CALORIFIC_VALUE 0x00000010 +#define EMBER_AF_METERING_NF2_PUBLISH_CO2_VALUE 0x00000020 +#define EMBER_AF_METERING_NF2_PUBLISH_BILLING_PERIOD 0x00000040 +#define EMBER_AF_METERING_NF2_PUBLISH_CONSOLIDATED_BILL 0x00000080 +#define EMBER_AF_METERING_NF2_PUBLISH_PRICE_MATRIX 0x00000100 +#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_THRESHOLDS 0x00000200 +#define EMBER_AF_METERING_NF2_PUBLISH_CURRENCY_CONVERSION 0x00000400 +#define EMBER_AF_METERING_NF2_PUBLISH_CREDIT_PAYMENT_INFO 0x00001000 +#define EMBER_AF_METERING_NF2_PUBLISH_CPP_EVENT 0x00002000 +#define EMBER_AF_METERING_NF2_PUBLISH_TIER_LABELS 0x00004000 +#define EMBER_AF_METERING_NF2_CANCEL_TARIFF 0x00008000 + +// Notification Flags 3 +#define EMBER_AF_METERING_NF3_PUBLISH_CALENDAR 0x00000001 +#define EMBER_AF_METERING_NF3_PUBLISH_SPECIAL_DAYS 0x00000002 +#define EMBER_AF_METERING_NF3_PUBLISH_SEASONS 0x00000004 +#define EMBER_AF_METERING_NF3_PUBLISH_WEEK 0x00000008 +#define EMBER_AF_METERING_NF3_PUBLISH_DAY 0x00000010 +#define EMBER_AF_METERING_NF3_CANCEL_CALENDAR 0x00000020 + +// Notification Flags 4 +#define EMBER_AF_METERING_NF4_SELECT_AVAILABLE_EMERGENCY_CREDIT 0x00000001 +#define EMBER_AF_METERING_NF4_CHANGE_DEBT 0x00000002 +#define EMBER_AF_METERING_NF4_EMERGENCY_CREDIT_SETUP 0x00000004 +#define EMBER_AF_METERING_NF4_CONSUMER_TOP_UP 0x00000008 +#define EMBER_AF_METERING_NF4_CREDIT_ADJUSTMENT 0x00000010 +#define EMBER_AF_METERING_NF4_CHANGE_PAYMENT_MODE 0x00000020 +#define EMBER_AF_METERING_NF4_GET_PREPAY_SNAPSHOT 0x00000040 +#define EMBER_AF_METERING_NF4_GET_TOP_UP_LOG 0x00000080 +#define EMBER_AF_METERING_NF4_SET_LOW_CREDIT_WARNING_LEVEL 0x00000100 +#define EMBER_AF_METERING_NF4_GET_DEBT_REPAYMENT_LOG 0x00000200 +#define EMBER_AF_METERING_NF4_SET_MAXIMUM_CREDIT_LIMIT 0x00000400 +#define EMBER_AF_METERING_NF4_SET_OVERALL_DEBT_CAP 0x00000800 + +// Notification Flags 5 +#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_TENANCY 0x00000001 +#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_SUPPLIER 0x00000002 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_1_RESPONSE 0x00000004 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_2_RESPONSE 0x00000008 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_3_RESPONSE 0x00000010 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_4_RESPONSE 0x00000020 +#define EMBER_AF_METERING_NF5_UPDATE_SITE_ID 0x00000040 +#define EMBER_AF_METERING_NF5_RESET_BATTERY_COUNTER 0x00000080 +#define EMBER_AF_METERING_NF5_UPDATE_CIN 0x00000100 + +/** + * @brief CBKE Library types + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfCbkeKeyEstablishmentSuite +#else +typedef uint16_t EmberAfCbkeKeyEstablishmentSuite; +enum +#endif +{ + EMBER_AF_INVALID_KEY_ESTABLISHMENT_SUITE = 0x0000, + EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_163K1 = 0x0001, + EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_283K1 = 0x0002, +}; + +/** + * @brief Device Management plugin types + */ + +#define EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH (16) +#define EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH (18) +#define EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH (32) +#define EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH (24) +#define EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH (10) + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfDeviceManagementPasswordType +#else +typedef uint16_t EmberAfDeviceManagementPasswordType; +enum +#endif +{ + UNUSED_PASSWORD = 0x00, + SERVICE_PASSWORD = 0x01, + CONSUMER_PASSWORD = 0x02, +}; + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAfDeviceManagementChangePendingFlags +#else +typedef uint8_t EmberAfDeviceManagementChangePendingFlags; +enum +#endif +{ + EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_TENANCY_PENDING_MASK = 0x01, + EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_SUPPLIER_PENDING_MASK = 0x02, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SITE_ID_PENDING_MASK = 0x04, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CIN_PENDING_MASK = 0x08, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SERVICE_PASSWORD_PENDING_MASK = 0x10, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CONSUMER_PASSWORD_PENDING_MASK = 0x20, +}; + +typedef struct { + // Optional fields only used by Gas Proxy Function plugin. + uint32_t providerId; + uint32_t issuerEventId; + uint8_t tariffType; + + // always used fields + uint32_t implementationDateTime; + uint32_t tenancy; +} EmberAfDeviceManagementTenancy; + +typedef struct { + uint32_t proposedProviderId; + uint32_t implementationDateTime; + uint32_t providerChangeControl; + uint8_t proposedProviderName[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH + 1]; + uint8_t proposedProviderContactDetails[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH + 1]; +} EmberAfDeviceManagementSupplier; + +typedef struct { + uint32_t requestDateTime; + uint32_t implementationDateTime; + uint8_t supplyStatus; + uint8_t originatorIdSupplyControlBits; +} EmberAfDeviceManagementSupply; + +typedef struct { + uint8_t siteId[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH + 1]; + uint32_t implementationDateTime; + uint32_t issuerEventId; +} EmberAfDeviceManagementSiteId; + +typedef struct { + uint8_t cin[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH + 1]; + uint32_t implementationDateTime; + uint32_t issuerEventId; +} EmberAfDeviceManagementCIN; + +typedef struct { + bool supplyTamperState; + bool supplyDepletionState; + bool supplyUncontrolledFlowState; + bool loadLimitSupplyState; +} EmberAfDeviceManagementSupplyStatusFlags; + +typedef struct { + uint16_t uncontrolledFlowThreshold; + uint16_t multiplier; + uint16_t divisor; + uint16_t measurementPeriod; + uint8_t unitOfMeasure; + uint8_t stabilisationPeriod; +} EmberAfDeviceManagementUncontrolledFlowThreshold; + +typedef struct { + uint32_t implementationDateTime; + uint8_t supplyStatus; +} EmberAfDeviceManagementSupplyStatus; + +typedef struct { + uint8_t password[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH + 1]; + uint32_t implementationDateTime; + uint16_t durationInMinutes; + EmberAfDeviceManagementPasswordType passwordType; +} EmberAfDeviceManagementPassword; + +typedef struct { + EmberAfDeviceManagementTenancy tenancy; + EmberAfDeviceManagementSupplier supplier; + EmberAfDeviceManagementSupply supply; + EmberAfDeviceManagementSiteId siteId; + EmberAfDeviceManagementCIN cin; + EmberAfDeviceManagementSupplyStatusFlags supplyStatusFlags; + EmberAfDeviceManagementSupplyStatus supplyStatus; + //TODO: These passwords ought to be tokenized / hashed + EmberAfDeviceManagementPassword servicePassword; + EmberAfDeviceManagementPassword consumerPassword; + EmberAfDeviceManagementUncontrolledFlowThreshold threshold; + uint32_t providerId; + uint32_t issuerEventId; + uint8_t proposedLocalSupplyStatus; + EmberAfTariffType tariffType; + EmberAfDeviceManagementChangePendingFlags pendingUpdates; +} EmberAfDeviceManagementInfo; + +typedef struct { + uint8_t startIndex; + uint8_t endIndex; +} EmberAfDeviceManagementAttributeRange; + +// attrRange is a list of attributeId values in a cluster. It's needed to track contigous +// segments of valid attributeId's with gaps in the middle. +// attributeSetId is the value of the upper byte in the attributeId. It ranges from 0x01(Price) +// to 0x08(OTA Event Configuration) +// Eg. {0x00,0x05} and {0x08,0x0A} +// We're betting that there isn't a list of cluster attributes that has more than 5 gaps. +typedef struct { + uint8_t attributeSetId; + EmberAfDeviceManagementAttributeRange attributeRange[7]; +} EmberAfDeviceManagementAttributeTable; + +typedef struct { + bool encryption; + + uint8_t * plainPayload; + uint16_t plainPayloadLength; + + uint8_t * encryptedPayload; + uint16_t encryptedPayloadLength; +} EmberAfGbzMessageData; + +typedef struct { + uint8_t * gbzCommands; + uint16_t gbzCommandsLength; + uint8_t * gbzCommandsResponse; + uint16_t gbzCommandsResponseLength; + uint16_t messageCode; +} EmberAfGpfMessage; + +/** + * @brief Zigbee Internet Client/Server Remote Cluster Types + */ +typedef uint16_t EmberAfRemoteClusterType; + +#define EMBER_AF_REMOTE_CLUSTER_TYPE_NONE 0x0000 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_SERVER 0x0001 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_CLIENT 0x0002 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_INVALID 0xFFFF + +/** + * @brief Zigbee Internet Client/Server remote cluster struct. + */ +typedef struct { + EmberAfClusterId clusterId; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; + EmberAfRemoteClusterType type; +} EmberAfRemoteClusterStruct; + +/** + * @brief Zigbee Internet Client/Server Remote Binding struct + */ +typedef struct { + EmberEUI64 targetEUI64; + uint8_t sourceEndpoint; + uint8_t destEndpoint; + uint16_t clusterId; + EmberEUI64 destEUI64; + EmberEUI64 sourceEUI64; +} EmberAfRemoteBindingStruct; + +typedef struct { + EmberAfClusterId clusterId; + bool server; +} EmberAfClusterInfo; + +#if !defined(EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT) + #define EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT 3 +#endif + +/** + * @brief A struct containing basic information about an endpoint. + */ +typedef struct { + EmberAfClusterInfo clusters[EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT]; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; + uint8_t clusterCount; +} EmberAfEndpointInfoStruct; + +#if !defined(EMBER_AF_MAX_ENDPOINTS_PER_DEVICE) + #define EMBER_AF_MAX_ENDPOINTS_PER_DEVICE 1 +#endif + +// Although we treat this like a bitmap, only 1 bit is set at a time. +// We use the bitmap feature to allow us to find all devices +// with any in a set of status codes using +// emberAfPluginDeviceDatabaseFindDeviceByStatus(). +typedef enum { + EMBER_AF_DEVICE_DISCOVERY_STATUS_NONE = 0x00, + EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW = 0x01, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS = 0x02, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS = 0x04, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_STACK_REVISION = 0x08, + + EMBER_AF_DEVICE_DISCOVERY_STATUS_DONE = 0x40, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FAILED = 0x80, +} EmberAfDeviceDiscoveryStatus; + +/** + * @brief A struct containing endpoint information about a device. + */ +typedef struct { + EmberEUI64 eui64; + EmberAfEndpointInfoStruct endpoints[EMBER_AF_MAX_ENDPOINTS_PER_DEVICE]; + EmberAfDeviceDiscoveryStatus status; + uint8_t discoveryFailures; + uint8_t capabilities; + uint8_t endpointCount; + uint8_t stackRevision; +} EmberAfDeviceInfo; + +typedef struct { + uint16_t deviceIndex; +} EmberAfDeviceDatabaseIterator; + +typedef struct { + EmberNodeId emberNodeId; + uint32_t timeStamp; +} EmberAfJoiningDevice; + +#define EMBER_AF_INVALID_CLUSTER_ID 0xFFFF + +#define EMBER_AF_INVALID_ENDPOINT 0xFF + +#define EMBER_AF_INVALID_PAN_ID 0xFFFF + +/** + * @brief Permit join times + */ +#define EMBER_AF_PERMIT_JOIN_FOREVER 0xFF +#define EMBER_AF_PERMIT_JOIN_MAX_TIMEOUT 0xFE + +/** + * @brief The overhead of the ZDO response. + * 1 byte for the sequence and 1 byte for the status code. + */ +#define EMBER_AF_ZDO_RESPONSE_OVERHEAD 2 + +/** @} END addtogroup */ + +#endif // SILABS_AF_API_TYPES diff --git a/examples/wifi-echo/server/esp32/main/af.h b/examples/wifi-echo/server/esp32/main/af.h new file mode 100644 index 00000000000000..d09e775107f096 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af.h @@ -0,0 +1,2061 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief The master include file for the Ember ApplicationFramework API. + ******************************************************************************* + ******************************************************************************/ + +/** + * @addtogroup af Zigbee Application Framework API Reference + * This documentation describes the application programming interface (API) + * for the Zigbee Application Framework. + * The file af.h is the master include file for the Zigbee Application + * Framework modules. + * @{ + */ + +#ifndef SILABS_AF_API +#define SILABS_AF_API + +// Micro and compiler specific typedefs and macros +#include PLATFORM_HEADER + +#ifndef CONFIGURATION_HEADER + #define CONFIGURATION_HEADER "app/framework/util/config.h" +#endif +#include CONFIGURATION_HEADER + +#ifdef EZSP_HOST +// Includes needed for ember related functions for the EZSP host + #include "stack/include/error.h" + #include "stack/include/ember-types.h" + #include "stack/include/ember-random-api.h" + #include "app/util/ezsp/ezsp-protocol.h" + #include "app/util/ezsp/ezsp.h" + #include "app/util/ezsp/ezsp-utils.h" + #include "app/util/ezsp/serial-interface.h" +#else +// Includes needed for ember related functions for the SoC + #include "stack/include/ember.h" +#endif // EZSP_HOST + +// HAL - hardware abstraction layer +#include "hal/hal.h" +#include "plugin/serial/serial.h" // Serial utility APIs + +#include "stack/include/event.h" +#include "stack/include/error.h" +#include "af-types.h" +#include "app/framework/util/print.h" +#include "app/framework/util/time-util.h" +#include "af-structs.h" +#include "attribute-id.h" +#include "att-storage.h" +#include "attribute-type.h" +#include "call-command-handler.h" +#include "callback.h" +#include "client-command-macro.h" +#include "cluster-id.h" +#include "command-id.h" +#include "debug-printing.h" +#include "enums.h" +#include "print-cluster.h" +#include "app/framework/util/client-api.h" +#include "app/util/serial/command-interpreter2.h" +#include "app/framework/cli/zcl-cli.h" + +/** @name Attribute Storage */ +// @{ + +/** + * @brief locate attribute metadata + * + * Function returns pointer to the attribute metadata structure, + * or NULL if attribute was not found. + * + * @param endpoint Zigbee endpoint number. + * @param cluster Cluster ID of the sought cluster. + * @param attribute Attribute ID of the sought attribute. + * @param mask CLUSTER_MASK_SERVER or CLUSTER_MASK_CLIENT + * + * @return Returns pointer to the attribute metadata location. + */ +EmberAfAttributeMetadata *emberAfLocateAttributeMetadata(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode); + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** @brief Returns true if the attribute exists. */ +bool emberAfContainsAttribute(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode); +#else + #define emberAfContainsAttribute(endpoint, clusterId, attributeId, mask, manufacturerCode) \ + (emberAfLocateAttributeMetadata(endpoint, clusterId, attributeId, mask, manufacturerCode) != NULL) +#endif + +/** + * @brief Returns true if endpoint contains a cluster, checking for mfg code. + * + * This function returns true regardless of whether + * the endpoint contains server, client or both. + * For standard libraries (when ClusterId < FC00), + * the manufacturerCode is ignored. + */ +bool emberAfContainsClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode); + +/** + * @brief Returns true if endpoint contains the ZCL cluster with specified id. + * + * This function returns true regardless of whether + * the endpoint contains server, client or both in the Zigbee cluster Library. + * This wraps emberAfContainsClusterWithMfgCode with + * manufacturerCode = EMBER_AF_NULL_MANUFACTURER_CODE + * If this function is used with a manufacturer specific clusterId + * then this will return the first cluster that it finds in the Cluster table. + * and will not return any other clusters that share that id. + */ +bool emberAfContainsCluster(uint8_t endpoint, EmberAfClusterId clusterId); + +/** + * @brief Returns true if endpoint has cluster server, checking for mfg code. + * + * This function returns true if + * the endpoint contains server of a given cluster. + * For standard librarys (when ClusterId < FC00), the manufacturerCode is ignored. + */ +bool emberAfContainsServerWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode); + +/** + * @brief Returns true if endpoint contains the ZCL server with specified id. + * + * This function returns true if + * the endpoint contains server of a given cluster. + * This wraps emberAfContainsServer with + * manufacturerCode = EMBER_AF_NULL_MANUFACTURER_CODE + * If this function is used with a manufacturer specific clusterId + * then this will return the first cluster that it finds in the Cluster table. + * and will not return any other clusters that share that id. + */ +bool emberAfContainsServer(uint8_t endpoint, EmberAfClusterId clusterId); + +/** + * @brief Returns true if endpoint contains cluster client. + * + * This function returns true if + * the endpoint contains client of a given cluster. + * For standard library clusters (when ClusterId < FC00), + * the manufacturerCode is ignored. + */ +bool emberAfContainsClientWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode); + +/** + * @brief Returns true if endpoint contains the ZCL client with specified id. + * + * This function returns true if + * the endpoint contains client of a given cluster. + * This wraps emberAfContainsClient with + * manufacturerCode = EMBER_AF_NULL_MANUFACTURER_CODE + * If this function is used with a manufacturer specific clusterId + * then this will return the first cluster that it finds in the Cluster table. + * and will not return any other clusters that share that id. + */ +bool emberAfContainsClient(uint8_t endpoint, EmberAfClusterId clusterId); + +/** + * @brief write an attribute, performing all the checks. + * + * This function will attempt to write the attribute value from + * the provided pointer. This function will only check that the + * attribute exists. If it does it will write the value into + * the attribute table for the given attribute. + * + * This function will not check to see if the attribute is + * writable since the read only / writable characteristic + * of an attribute only pertains to external devices writing + * over the air. Because this function is being called locally + * it assumes that the device knows what it is doing and has permission + * to perform the given operation. + * + * @see emberAfWriteClientAttribute, emberAfWriteServerAttribute, + * emberAfWriteManufacturerSpecificClientAttribute, + * emberAfWriteManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief write a cluster server attribute. + * + * This function is the same as emberAfWriteAttribute + * except that it saves having to pass the cluster mask. + * This is useful for code savings since write attribute + * is used frequently throughout the framework + * + * @see emberAfWriteClientAttribute, + * emberAfWriteManufacturerSpecificClientAttribute, + * emberAfWriteManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief write a cluster client attribute. + * + * This function is the same as emberAfWriteAttribute + * except that it saves having to pass the cluster mask. + * This is useful for code savings since write attribute + * is used frequently throughout the framework + * + * @see emberAfWriteServerAttribute, + * emberAfWriteManufacturerSpecificClientAttribute, + * emberAfWriteManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief write a manufacturer specific server attribute. + * + * This function is the same as emberAfWriteAttribute + * except that it saves having to pass the cluster mask + * and allows passing of a manufacturer code. + * This is useful for code savings since write attribute + * is used frequently throughout the framework + * + * @see emberAfWriteClientAttribute, emberAfWriteServerAttribute, + * emberAfWriteManufacturerSpecificClientAttribute + */ +EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief write a manufacturer specific client attribute. + * + * This function is the same as emberAfWriteAttribute + * except that it saves having to pass the cluster mask. + * and allows passing of a manufacturer code. + * This is useful for code savings since write attribute + * is used frequently throughout the framework + * + * @see emberAfWriteClientAttribute, emberAfWriteServerAttribute, + * emberAfWriteManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief Function that test the success of attribute write. + * + * This function returns success if attribute write would be successful. + * It does not actually write anything, just validates for read-only and + * data-type. + * + * @param endpoint Zigbee endpoint number + * @param cluster Cluster ID of the sought cluster. + * @param attribute Attribute ID of the sought attribute. + * @param mask CLUSTER_MASK_SERVER or CLUSTER_MASK_CLIENT + * @param buffer Location where attribute will be written from. + * @param dataType ZCL attribute type. + */ +EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +/** + * @brief Read the attribute value, performing all the checks. + * + * This function will attempt to read the attribute and store + * it into the pointer. It will also read the data type. + * Both dataPtr and dataType may be NULL, signifying that either + * value or type is not desired. + * + * @see emberAfReadClientAttribute, emberAfReadServerAttribute, + * emberAfReadManufacturerSpecificClientAttribute, + * emberAfReadManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfReadAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint8_t* dataPtr, + uint8_t readLength, + EmberAfAttributeType* dataType); + +/** + * @brief Read the server attribute value, performing all the checks. + * + * This function will attempt to read the attribute and store + * it into the pointer. It will also read the data type. + * Both dataPtr and dataType may be NULL, signifying that either + * value or type is not desired. + * + * @see emberAfReadClientAttribute, + * emberAfReadManufacturerSpecificClientAttribute, + * emberAfReadManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + uint8_t readLength); + +/** + * @brief Read the client attribute value, performing all the checks. + * + * This function will attempt to read the attribute and store + * it into the pointer. It will also read the data type. + * Both dataPtr and dataType may be NULL, signifying that either + * value or type is not desired. + * + * @see emberAfReadServerAttribute, + * emberAfReadManufacturerSpecificClientAttribute, + * emberAfReadManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + uint8_t readLength); + +/** + * @brief Read the manufacturer-specific server attribute value, performing all checks. + * + * This function will attempt to read the attribute and store + * it into the pointer. It will also read the data type. + * Both dataPtr and dataType may be NULL, signifying that either + * value or type is not desired. + * + * @see emberAfReadClientAttribute, emberAfReadServerAttribute, + * emberAfReadManufacturerSpecificClientAttribute + */ +EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + uint8_t readLength); + +/** + * @brief Read the manufacturer-specific client attribute value, performing all checks. + * + * This function will attempt to read the attribute and store + * it into the pointer. It will also read the data type. + * Both dataPtr and dataType may be NULL, signifying that either + * value or type is not desired. + * + * @see emberAfReadClientAttribute, emberAfReadServerAttribute, + * emberAfReadManufacturerSpecificServerAttribute + */ +EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + uint8_t readLength); + +/** + * @brief this function returns the size of the ZCL data in bytes. + * + * @param dataType Zcl data type + * @return size in bytes or 0 if invalid data type + */ +uint8_t emberAfGetDataSize(uint8_t dataType); + +/** + * @brief macro that returns true if the cluster is in the manufacturer specific range + * + * @param cluster EmberAfCluster* to consider + */ +#define emberAfClusterIsManufacturerSpecific(cluster) ((cluster)->clusterId >= 0xFC00) + +/** + * @brief macro that returns true if attribute is read only. + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsReadOnly(metadata) (((metadata)->mask & ATTRIBUTE_MASK_WRITABLE) == 0) + +/** + * @brief macro that returns true if client attribute, and false if server. + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsClient(metadata) (((metadata)->mask & ATTRIBUTE_MASK_CLIENT) != 0) + +/** + * @brief macro that returns true if attribute is saved to token. + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsTokenized(metadata) (((metadata)->mask & ATTRIBUTE_MASK_TOKENIZE) != 0) + +/** + * @brief macro that returns true if attribute is saved in external storage. + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsExternal(metadata) (((metadata)->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE) != 0) + +/** + * @brief macro that returns true if attribute is a singleton + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsSingleton(metadata) (((metadata)->mask & ATTRIBUTE_MASK_SINGLETON) != 0) + +/** + * @brief macro that returns true if attribute is manufacturer specific + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeIsManufacturerSpecific(metadata) (((metadata)->mask & ATTRIBUTE_MASK_MANUFACTURER_SPECIFIC) != 0) + +/** + * @brief macro that returns size of attribute in bytes. + * + * @param metadata EmberAfAttributeMetadata* to consider. + */ +#define emberAfAttributeSize(metadata) ((metadata)->size) + +#if !defined(DOXYGEN_SHOULD_SKIP_THIS) +// master array of all defined endpoints +extern EmberAfDefinedEndpoint emAfEndpoints[]; + +// Master array of all zigbee PRO networks. +extern const EmAfZigbeeProNetwork emAfZigbeeProNetworks[]; + +// The current zigbee PRO network or NULL. +extern const EmAfZigbeeProNetwork *emAfCurrentZigbeeProNetwork; + +// true if the current network is a zigbee PRO network. +#define emAfProIsCurrentNetwork() (emAfCurrentZigbeeProNetwork != NULL) +#endif + +/** + * @brief Macro that takes index of endpoint, and returns Zigbee endpoint + */ +uint8_t emberAfEndpointFromIndex(uint8_t index); + +/** + * Returns the index of a given endpoint + */ +uint8_t emberAfIndexFromEndpoint(uint8_t endpoint); + +/** + * Returns the index of a given endpoint; Does not ignore disabled endpoints + */ +uint8_t emberAfIndexFromEndpointIncludingDisabledEndpoints(uint8_t endpoint); + +/** + * Returns the endpoint index within a given cluster (Client-side), + * looking only for standard clusters. + */ +uint8_t emberAfFindClusterClientEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId); + +/** + * Returns the endpoint index within a given cluster (Server-side), + * looking only for standard clusters. + */ +uint8_t emberAfFindClusterServerEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId); + +/** + * @brief Macro that takes index of endpoint, and returns profile Id for it + */ +#define emberAfProfileIdFromIndex(index) (emAfEndpoints[(index)].profileId) + +/** + * @brief Macro that takes index of endpoint, and returns device Id for it + */ +#define emberAfDeviceIdFromIndex(index) (emAfEndpoints[(index)].deviceId) + +/** + * @brief Macro that takes index of endpoint, and returns device version for it + */ +#define emberAfDeviceVersionFromIndex(index) (emAfEndpoints[(index)].deviceVersion) + +/** + * @brief Macro that takes index of endpoint, and returns network index for it + */ +#define emberAfNetworkIndexFromEndpointIndex(index) (emAfEndpoints[(index)].networkIndex) + +/** + * @brief Returns the network index of a given endpoint. + */ +uint8_t emberAfNetworkIndexFromEndpoint(uint8_t endpoint); + +/** + * @brief Macro that returns primary profile ID. + * + * Primary profile is the profile of a primary endpoint as defined + * in AppBuilder. + */ +#define emberAfPrimaryProfileId() emberAfProfileIdFromIndex(0) + +/** + * @brief Macro that returns the primary endpoint. + */ +#define emberAfPrimaryEndpoint() (emAfEndpoints[0].endpoint) + +/** + * @brief Returns the total number of endpoints (dynamic and pre-compiled). + */ +uint8_t emberAfEndpointCount(void); + +/** + * @brief Returns the number of pre-compiled endpoints. + */ +uint8_t emberAfFixedEndpointCount(void); + +/** + * Data types are either analog or discrete. This makes a difference for + * some of the ZCL global commands + */ +enum { + EMBER_AF_DATA_TYPE_ANALOG = 0, + EMBER_AF_DATA_TYPE_DISCRETE = 1, + EMBER_AF_DATA_TYPE_NONE = 2 +}; + +/** + * @brief Returns the type of the attribute, either ANALOG, DISCRETE or NONE + */ +uint8_t emberAfGetAttributeAnalogOrDiscreteType(uint8_t dataType); + +/** + *@brief Returns true if type is signed, false otherwise. + */ +bool emberAfIsTypeSigned(EmberAfAttributeType dataType); + +/** + * @brief Function that extracts a 32-bit integer from the message buffer + */ +uint32_t emberAfGetInt32u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); + +/** + * @brief Function that extracts a 24-bit integer from the message buffer + */ +uint32_t emberAfGetInt24u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); + +/** + * @brief Function that extracts a 16-bit integer from the message buffer + */ +uint16_t emberAfGetInt16u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +/** + * @brief Function that extracts a ZCL string from the message buffer + */ +uint8_t* emberAfGetString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +/** + * @brief Function that extracts a ZCL long string from the message buffer + */ +uint8_t* emberAfGetLongString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +/* + * @brief Function that extracts a ZCL Date from the message buffer and returns it + * in the given destination. Returns the number of bytes copied. + */ +uint8_t emberAfGetDate(uint8_t* message, uint16_t currentIndex, uint16_t msgLen, EmberAfDate *destination); + +/** + * @brief Macro for consistency, that extracts single byte out of the message + */ +#define emberAfGetInt8u(message, currentIndex, msgLen) message[currentIndex] + +/** + * @brief Macro for consistency that copies a uint8_t from variable into buffer. + */ +#define emberAfCopyInt8u(data, index, x) (data[index] = (x)) +/** + * @brief function that copies a uint16_t value into a buffer + */ +void emberAfCopyInt16u(uint8_t *data, uint16_t index, uint16_t x); +/** + * @brief function that copies a uint24_t value into a buffer + */ +void emberAfCopyInt24u(uint8_t *data, uint16_t index, uint32_t x); +/** + * @brief function that copies a uint32_t value into a buffer + */ +void emberAfCopyInt32u(uint8_t *data, uint16_t index, uint32_t x); +/* + * @brief Function that copies a ZCL string type into a buffer. The size + * parameter should indicate the maximum number of characters to copy to the + * destination buffer not including the length byte. + */ +void emberAfCopyString(uint8_t *dest, uint8_t *src, uint8_t size); +/* + * @brief Function that copies a ZCL long string into a buffer. The size + * parameter should indicate the maximum number of characters to copy to the + * destination buffer not including the length bytes. + */ +void emberAfCopyLongString(uint8_t *dest, uint8_t *src, uint16_t size); +/* + * @brief Function that determines the length of a zigbee Cluster Library string + * (where the first byte is assumed to be the length). + */ +uint8_t emberAfStringLength(const uint8_t *buffer); +/* + * @brief Function that determines the length of a zigbee Cluster Library long string. + * (where the first two bytes are assumed to be the length). + */ +uint16_t emberAfLongStringLength(const uint8_t *buffer); + +/* + * @brief Function that determines the size of a zigbee Cluster Library + * attribute value (where the attribute could be non-string, string, or long + * string). For strings, the size includes the length of the string plus the + * number of the string's length prefix byte(s). + */ +uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, + const uint8_t *buffer); + +/** @} END Attribute Storage */ + +/** @name Device Control */ +// @{ + +/** + * @brief Function that checks if endpoint is enabled. + * + * This function returns true if device at a given endpoint is + * enabled. At startup all endpoints are enabled. + * + * @param endpoint Zigbee endpoint number + */ +bool emberAfIsDeviceEnabled(uint8_t endpoint); + +/** + * @brief Function that checks if endpoint is identifying + * + * This function returns true if device at a given endpoint is + * identifying. + * + * @param endpoint Zigbee endpoint number + */ +bool emberAfIsDeviceIdentifying(uint8_t endpoint); + +/** + * @brief Function that enables or disables an endpoint. + * + * By calling this function, you turn off all processing of incoming traffic + * for a given endpoint. + * + * @param endpoint Zigbee endpoint number + */ +void emberAfSetDeviceEnabled(uint8_t endpoint, bool enabled); + +/** @} END Device Control */ + +/** @name Miscellaneous */ +// @{ + +/** + * @brief Enable/disable endpoints + */ +bool emberAfEndpointEnableDisable(uint8_t endpoint, bool enable); + +/** + * @brief Determine if an endpoint at the specified index is enabled or disabled + */ +bool emberAfEndpointIndexIsEnabled(uint8_t index); + +/** + * @brief This indicates a new image verification is taking place. + */ +#define EMBER_AF_NEW_IMAGE_VERIFICATION true + +/** + * @brief This indicates the continuation of an image verification already + * in progress. + */ +#define EMBER_AF_CONTINUE_IMAGE_VERIFY false + +/** + * @brief This variable defines an invalid image id. It is used + * to determine if a returned EmberAfOtaImageId is valid or not. + * This is done by passing the data to the function + * emberAfIsOtaImageIdValid(). + */ +extern const EmberAfOtaImageId emberAfInvalidImageId; + +/** + * @brief Returns true if a given ZCL data type is a string type. + * + * You should use this function if you need to perform a different + * memory operation on a certain attribute because it is a string type. + * Since ZCL strings carry length as the first byte(s), it is often required + * to treat them differently than regular data types. + * + * @return true if data type is a string. + */ +bool emberAfIsThisDataTypeAStringType(EmberAfAttributeType dataType); + +/** @brief Returns true if the given attribute type is a string. */ +bool emberAfIsStringAttributeType(EmberAfAttributeType attributeType); + +/** @brief Returns true if the given attribute type is a long string. */ +bool emberAfIsLongStringAttributeType(EmberAfAttributeType attributeType); + +/** + * @brief The mask applied by ::emberAfNextSequence when generating ZCL + * sequence numbers. + */ +#define EMBER_AF_ZCL_SEQUENCE_MASK 0x7F + +/** + * @brief The mask applied to generated message tags used by the framework when sending messages via EZSP. + * Customers who call ezspSend functions directly must use message tags outside this mask + */ +#define EMBER_AF_MESSAGE_TAG_MASK 0x7F + +/** + * @brief Increments the ZCL sequence number and returns the value. + * + * ZCL messages have sequence numbers so that they can be matched up with other + * messages in the transaction. To avoid conflicts with sequence numbers + * generated independently by the application, this API returns sequence + * numbers with the high bit clear. If the application generates its own + * sequence numbers, it should use numbers with the high bit set. + * + * @return The next ZCL sequence number. + */ +uint8_t emberAfNextSequence(void); + +/** + * @brief Retrieves the last sequence number that was used. + * + */ +uint8_t emberAfGetLastSequenceNumber(void); + +/** + * @brief Simple integer comparison function. + * Compares two values of a known length as integers. + * Signed integer comparison are supported for numbers with length of + * 4 (bytes) or less. + * The integers are in native endianness. + * + * @return -1, if val1 is smaller + * 0, if they are the same or if two negative numbers with length + * greater than 4 is being compared + * 1, if val2 is smaller. + */ +int8_t emberAfCompareValues(uint8_t* val1, uint8_t* val2, uint8_t len, bool signedNumber); + +/** + * @brief populates the passed EUI64 with the local EUI64 MAC address. + */ +void emberAfGetEui64(EmberEUI64 returnEui64); + +#ifdef EZSP_HOST +// Normally this is provided by the stack code, but on the host +// it is provided by the application code. +void emberReverseMemCopy(uint8_t* dest, const uint8_t* src, uint16_t length); +#endif + +/** + * @brief Returns the node ID of the local node. + */ +EmberNodeId emberAfGetNodeId(void); + +#if defined(DOXYGEN_SHOULD_SKIP_THIS) || defined(EZSP_HOST) +/** + * @brief Generates a random key (link, network, or master). + */ +EmberStatus emberAfGenerateRandomKey(EmberKeyData *result); +#else + #define emberAfGenerateRandomKey(result) emberGenerateRandomKey(result) +#endif + +/** + * @brief Returns the PAN ID of the local node. + */ +EmberPanId emberAfGetPanId(void); + +/** + * @brief Returns the radioChannel of the current network + */ +uint8_t emberAfGetRadioChannel(void); + +/* + * @brief Returns a binding index that matches the current incoming message, if + * known. + */ +uint8_t emberAfGetBindingIndex(void); + +/* + * @brief Returns an address index that matches the current incoming message, + * if known. + */ +uint8_t emberAfGetAddressIndex(void); + +/** + * @brief Returns the current network state. This call caches the results + * on the host to prevent frequent EZSP transactions. + */ +EmberNetworkStatus emberAfNetworkState(void); + +/** + * @brief Get this node's radio channel for the current network. + */ +uint8_t emberAfGetRadioChannel(void); + +/** + * @brief Returns the current network parameters. + */ +EmberStatus emberAfGetNetworkParameters(EmberNodeType *nodeType, + EmberNetworkParameters *parameters); + +/** + * @brief Returns the current node type. + */ +EmberStatus emberAfGetNodeType(EmberNodeType *nodeType); + +/** + */ +#define EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE 0xA0 +#define EMBER_AF_REJOIN_DUE_TO_TC_KEEPALIVE_FAILURE 0xA1 +#define EMBER_AF_REJOIN_DUE_TO_CLI_COMMAND 0xA2 +#define EMBER_AF_REJOIN_DUE_TO_WWAH_CONNECTIVITY_MANAGER 0xA3 + +#define EMBER_AF_REJOIN_FIRST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE +#define EMBER_AF_REJOIN_LAST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE + +/** + * @brief Enables local permit join and optionally broadcasts the ZDO + * Mgmt_Permit_Join_req message. This API can be called from any device + * type and still return EMBER_SUCCESS. If the API is called from an + * end device, the permit association bit will just be left off. + * + * @param duration the duration that the permit join bit will remain on + * and other devices will be able to join the current network. + * @param broadcastMgmtPermitJoin whether or not to broadcast the ZDO + * Mgmt_Permit_Join_req message. + * + * @returns status of whether or not permit join was enabled. + */ +EmberStatus emberAfPermitJoin(uint8_t duration, + bool broadcastMgmtPermitJoin); + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** + * @brief Enables local permit join and broadcasts the ZDO + * Mgmt_Permit_Join_req message. This API can be called from any device + * type and still return EMBER_SUCCESS. If the API is called from an + * end device, the permit association bit will just be left off. + * + * @param duration the duration that the permit join bit will remain on + * and other devices will be able to join the current network. + * + * @returns status of whether or not permit join was enabled. + */ +EmberStatus emberAfBroadcastPermitJoin(uint8_t duration); +#else + #define emberAfBroadcastPermitJoin(duration) \ + emberAfPermitJoin((duration), true) +#endif + +/** @} END Miscellaneous */ + +/** @name Sleep Control */ +//@{ + +/** + * @brief A function used to add a task to the task register. + */ +#define emberAfAddToCurrentAppTasks(x) \ + emberAfAddToCurrentAppTasksCallback(x) + +/** + * @brief A function used to remove a task from the task register. + */ +#define emberAfRemoveFromCurrentAppTasks(x) \ + emberAfRemoveFromCurrentAppTasksCallback(x) + +/** + * @brief A macro used to retrieve the bitmask of all application + * frameowrk tasks currently in progress. This can be useful for debugging if + * some task is holding the device out of hibernation. + */ +#define emberAfCurrentAppTasks() emberAfGetCurrentAppTasksCallback() + +/** + * @brief a function used to run the application framework's + * event mechanism. This function passes the application + * framework's event tables to the ember stack's event + * processing code. + */ +void emberAfRunEvents(void); + +/** + * @brief Friendly define for use in the scheduling or canceling client events + * with emberAfScheduleClusterTick() and emberAfDeactivateClusterTick(). + */ +#define EMBER_AF_CLIENT_CLUSTER_TICK true + +/** + * @brief Friendly define for use in the scheduling or canceling server events + * with emberAfScheduleClusterTick() and emberAfDeactivateClusterTick(). + */ +#define EMBER_AF_SERVER_CLUSTER_TICK false + +/** + * @brief This function is used to schedule a cluster-related event inside the + * application framework's event mechanism. This function provides a wrapper + * for the Ember stack event mechanism which allows the cluster code to access + * its events by their endpoint, cluster id, and client/server identity. The + * passed poll and sleep controls allow the cluster to indicate whether it + * needs to long or short poll and whether it needs to stay awake or if it can + * sleep. + * + * @param endpoint the endpoint of the event to be scheduled. + * @param clusterId the cluster id of the event to be scheduled. + * @param isClient ::EMBER_AF_CLIENT_CLUSTER_TICK if the event to be scheduled + * is associated with a client cluster or ::EMBER_AF_SERVER_CLUSTER_TICK + * otherwise. + * @param delayMs the number of milliseconds until the event should be called. + * @param pollControl ::EMBER_AF_SHORT_POLL if the cluster needs to short poll + * or ::EMBER_AF_LONG_POLL otherwise. + * @param sleepControl ::EMBER_AF_STAY_AWAKE if the cluster needs to stay awake + * or EMBER_AF_OK_TO_SLEEP otherwise. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleTickExtended(uint8_t endpoint, + EmberAfClusterId clusterId, + bool isClient, + uint32_t delayMs, + EmberAfEventPollControl pollControl, + EmberAfEventSleepControl sleepControl); + +/** + * @brief This function is used to schedule a cluster-related event inside the + * This function is a wrapper for ::emberAfScheduleTickExtended. The cluster + * on the given endpoint will be set to long poll if sleepControl is set to + * ::EMBER_AF_OK_TO_HIBERNATE or will be set to short poll otherwise. It will + * stay awake if sleepControl is ::EMBER_AF_STAY_AWAKE and will sleep + * otherwise. + * + * @param endpoint the endpoint of the event to be scheduled. + * @param clusterId the cluster id of the event to be scheduled. + * @param isClient ::EMBER_AF_CLIENT_CLUSTER_TICK if the event to be scheduled + * is associated with a client cluster or ::EMBER_AF_SERVER_CLUSTER_TICK + * otherwise. + * @param delayMs the number of milliseconds until the event should be called. + * @param sleepControl the priority of the event, what the processor should + * be allowed to do in terms of sleeping while the event is active. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleClusterTick(uint8_t endpoint, + EmberAfClusterId clusterId, + bool isClient, + uint32_t delayMs, + EmberAfEventSleepControl sleepControl); + +/** + * @brief A function used to schedule a cluster client event. This function + * is a wrapper for ::emberAfScheduleTickExtended. + * + * @param endpoint the endpoint of the event to be scheduled + * @param clusterId the cluster id of the event to be scheduled + * @param delayMs the number of milliseconds until the event should be called. + * @param pollControl ::EMBER_AF_SHORT_POLL if the cluster needs to short poll + * or ::EMBER_AF_LONG_POLL otherwise. + * @param sleepControl ::EMBER_AF_STAY_AWAKE if the cluster needs to stay awake + * or EMBER_AF_OK_TO_SLEEP otherwise. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleClientTickExtended(uint8_t endpoint, + EmberAfClusterId clusterId, + uint32_t delayMs, + EmberAfEventPollControl pollControl, + EmberAfEventSleepControl sleepControl); + +/** + * @brief A function used to schedule a cluster client event. This function + * is a wrapper for ::emberAfScheduleClientTickExtended. It indicates that + * the cluster client on the given endpoint can long poll and can sleep. + * + * @param endpoint the endpoint of the event to be scheduled. + * @param clusterId the cluster id of the event to be scheduled. + * @param delayMs the number of milliseconds until the event should be called. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleClientTick(uint8_t endpoint, + EmberAfClusterId clusterId, + uint32_t delayMs); + +/** + * @brief A function used to schedule a cluster server event. This function + * is a wrapper for ::emberAfScheduleTickExtended. + * + * @param endpoint the endpoint of the event to be scheduled. + * @param clusterId the cluster id of the event to be scheduled. + * @param delayMs the number of milliseconds until the event should be called. + * @param pollControl ::EMBER_AF_SHORT_POLL if the cluster needs to short poll + * or ::EMBER_AF_LONG_POLL otherwise. + * @param sleepControl ::EMBER_AF_STAY_AWAKE if the cluster needs to stay awake + * or EMBER_AF_OK_TO_SLEEP otherwise. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleServerTickExtended(uint8_t endpoint, + EmberAfClusterId clusterId, + uint32_t delayMs, + EmberAfEventPollControl pollControl, + EmberAfEventSleepControl sleepControl); + +/** + * @brief A function used to schedule a cluster server event. This function + * is a wrapper for ::emberAfScheduleServerTickExtended. It indicates that + * the cluster server on the given endpoint can long poll and can sleep. + * + * @param endpoint the endpoint of the event to be scheduled + * @param clusterId the cluster id of the event to be scheduled. + * @param delayMs the number of milliseconds until the event should be called. + * + * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. + */ +EmberStatus emberAfScheduleServerTick(uint8_t endpoint, + EmberAfClusterId clusterId, + uint32_t delayMs); + +/** + * @brief A function used to deactivate a cluster-related event. This function + * provides a wrapper for the Ember stack's event mechanism which allows an + * event to be accessed by its endpoint, cluster id, and client/server + * identity. + * + * @param endpoint the endpoint of the event to be deactivated. + * @param clusterId the cluster id of the event to be deactivated. + * @param isClient ::EMBER_AF_CLIENT_CLUSTER_TICK if the event to be + * deactivated is a client cluster ::EMBER_AF_SERVER_CLUSTER_TICK + * otherwise. + * + * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. + */ +EmberStatus emberAfDeactivateClusterTick(uint8_t endpoint, + EmberAfClusterId clusterId, + bool isClient); + +/** + * @brief A function used to deactivate a cluster client event. This function + * is a wrapper for ::emberAfDeactivateClusterTick. + * + * @param endpoint the endpoint of the event to be deactivated. + * @param clusterId the cluster id of the event to be deactivated. + * + * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. + */ +EmberStatus emberAfDeactivateClientTick(uint8_t endpoint, + EmberAfClusterId clusterId); + +/** + * @brief A function used to deactivate a cluster server event. This function + * is a wrapper for ::emberAfDeactivateClusterTick. + * + * @param endpoint the endpoint of the event to be deactivated. + * @param clusterId the cluster id of the event to be deactivated. + * + * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. + */ +EmberStatus emberAfDeactivateServerTick(uint8_t endpoint, + EmberAfClusterId clusterId); + +/** + * @brief Sets the ::EmberEventControl to run "delayMs" milliseconds in the + * future. This function first verifies that the delay is within the + * acceptable range before scheduling the event. + * + * @param control a pointer to the event control. + * @param delayMs the number of milliseconds until the next event. + * + * @return If delayMs is less than or equal to + ::EMBER_MAX_EVENT_CONTROL_DELAY_MS, this function will schedule the + event and return ::EMBER_SUCCESS. Otherwise it will return + ::EMBER_BAD_ARGUMENT. + */ +EmberStatus emberAfEventControlSetDelayMS(EmberEventControl *control, + uint32_t delayMs); + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** + * @brief Sets the ::EmberEventControl to run "delayMs" milliseconds in the + * future. See ::emberAfEventControlSetDelayMS. + */ +EmberStatus emberAfEventControlSetDelay(EmberEventControl *eventControl, + uint32_t delayMs); +#else +#define emberAfEventControlSetDelay(control, delayMs) \ + emberAfEventControlSetDelayMS(control, delayMs) +#endif + +/** + * @brief Sets the ::EmberEventControl to run "delayQs" quarter seconds in the + * future. The 'quarter seconds' are actually 256 milliseconds long. This + * function first verifies that the delay is within the acceptable range before + * scheduling the event. + * + * @param control a pointer to the event control. + * @param delayQs the number of quarter seconds until the next event. + * + * @return If delayQs is less than or equal to + ::EMBER_MAX_EVENT_CONTROL_DELAY_QS, this function will schedule the + event and return ::EMBER_SUCCESS. Otherwise it will return + ::EMBER_BAD_ARGUMENT. + */ +EmberStatus emberAfEventControlSetDelayQS(EmberEventControl *control, + uint32_t delayQs); + +/** + * @brief Sets the ::EmberEventControl to run "delayM" minutes in the future. + * The 'minutes' are actually 65536 (0x10000) milliseconds long. This function + * first verifies that the delay is within the acceptable range before + * scheduling the event. + * + * @param control a pointer to the event control. + * @param delayM the number of minutes until the next event. + * + * @return If delayM is less than or equal to + ::EMBER_MAX_EVENT_CONTROL_DELAY_MINUTES, this function will schedule + the event and return ::EMBER_SUCCESS. Otherwise it will return + ::EMBER_BAD_ARGUMENT. + */ +EmberStatus emberAfEventControlSetDelayMinutes(EmberEventControl *control, + uint16_t delayM); + +/** + * @brief Sets the ::EmberEventControl for the current network, and only + * the current network, as inactive. See ::emberEventControlSetInactive. + */ +void emberAfNetworkEventControlSetInactive(EmberEventControl *controls); +/** + * @brief Returns true if the event for the current network, and only the + * current network, is active. See ::emberEventControlGetActive. + */ +bool emberAfNetworkEventControlGetActive(EmberEventControl *controls); +/** + * @brief Sets the ::EmberEventControl for the current network, and only + * current network, to run at the next available opportunity. See + * ::emberEventControlSetActive. + */ +void emberAfNetworkEventControlSetActive(EmberEventControl *controls); +/** + * @brief Sets the ::EmberEventControl for the current network, and only the + * current network, to run "delayMs" milliseconds in the future. See + * ::emberAfEventControlSetDelayMS. + */ +EmberStatus emberAfNetworkEventControlSetDelayMS(EmberEventControl *controls, + uint32_t delayMs); +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** + * @brief Sets the ::EmberEventControl for the current network, and only the + * current network, to run "delayMs" milliseconds in the future. See + * ::emberAfEventControlSetDelayMS. + */ +EmberStatus emberAfNetworkEventControlSetDelay(EmberEventControl *controls, + uint32_t delayMs); +#else +#define emberAfNetworkEventControlSetDelay(controls, delayMs) \ + emberAfNetworkEventControlSetDelayMS(controls, delayMs); +#endif +/** + * @brief Sets the ::EmberEventControl for the current network, and only the + * current network, to run "delayQs" quarter seconds in the future. See + * ::emberAfEventControlSetDelayQS. + */ +EmberStatus emberAfNetworkEventControlSetDelayQS(EmberEventControl *controls, + uint32_t delayQs); +/** + * @brief Sets the ::EmberEventControl for the current network, and only the + * current network, to run "delayM" minutes in the future. See + * ::emberAfEventControlSetDelayMinutes. + */ +EmberStatus emberAfNetworkEventControlSetDelayMinutes(EmberEventControl *controls, + uint16_t delayM); + +/** + * @brief Sets the ::EmberEventControl for the specified endpoint as inactive. + * See ::emberEventControlSetInactive. + */ +EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl *controls, + uint8_t endpoint); +/** + * @brief Returns true if the event for the current number is active. See + * ::emberEventControlGetActive. + */ +bool emberAfEndpointEventControlGetActive(EmberEventControl *controls, + uint8_t endpoint); +/** + * @brief Sets the ::EmberEventControl for the specified endpoint to run at the + * next available opportunity. See ::emberEventControlSetActive. + */ +EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, + uint8_t endpoint); +/** + * @brief Sets the ::EmberEventControl for the specified endpoint to run + * "delayMs" milliseconds in the future. See ::emberAfEventControlSetDelayMS. + */ +EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl *controls, + uint8_t endpoint, + uint32_t delayMs); +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** + * @brief Sets the ::EmberEventControl for the specified endpoint to run + * "delayMs" milliseconds in the future. See ::emberAfEventControlSetDelayMS. + */ +EmberStatus emberAfEndpointEventControlSetDelay(EmberEventControl *controls, + uint8_t endpoint, + uint32_t delayMs); +#else +#define emberAfEndpointEventControlSetDelay(controls, endpoint, delayMs) \ + emberAfEndpointEventControlSetDelayMS(controls, endpoint, delayMs); +#endif +/** + * @brief Sets the ::EmberEventControl for the specified endpoint to run + * "delayQs" quarter seconds in the future. See + * ::emberAfEventControlSetDelayQS. + */ +EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl *controls, + uint8_t endpoint, + uint32_t delayQs); +/** + * @brief Sets the ::EmberEventControl for the specified endpoint to run + * "delayM" minutes in the future. See ::emberAfEventControlSetDelayMinutes. + */ +EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl *controls, + uint8_t endpoint, + uint16_t delayM); + +/** + * @brief A function used to retrieve the number of milliseconds until + * the next event scheduled in the application framework's event + * mechanism. + * @param maxMs, the maximum number of milliseconds until the next + * event. + * @return The number of milliseconds until the next event or + * maxMs if no event is scheduled before then. + */ +uint32_t emberAfMsToNextEvent(uint32_t maxMs); + +/** @brief This is the same as the function emberAfMsToNextEvent() with the + * following addition. If returnIndex is non-NULL it returns the index + * of the event that is ready to fire next. + */ +uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); + +/** + * @brief A function used to retrieve the number of quarter seconds until + * the next event scheduled in the application framework's event + * mechanism. This function will round down and will return 0 if the + * next event must fire within a quarter second. + * @param maxQS, the maximum number of quarter seconds until the next + * event. + * @return The number of quarter seconds until the next event or + * maxQS if no event is scheduled before then. + */ +#define emberAfQSToNextEvent(maxQS) \ + (emberAfMsToNextEvent(maxQS * MILLISECOND_TICKS_PER_QUARTERSECOND) \ + / MILLISECOND_TICKS_PER_QUARTERSECOND) + +/** + * @brief A function for retrieving the most restrictive sleep + * control value for all scheduled events. This function is + * used by emberAfOkToNap and emberAfOkToHibernate to makes sure + * that there are no events scheduled which will keep the device + * from hibernating or napping. + * @return The most restrictive sleep control value for all + * scheduled events or the value returned by + * emberAfGetDefaultSleepControl() + * if no events are currently scheduled. The default + * sleep control value is initialized to + * EMBER_AF_OK_TO_HIBERNATE but can be changed at any + * time using the emberAfSetDefaultSleepControl() function. + */ +#define emberAfGetCurrentSleepControl() \ + emberAfGetCurrentSleepControlCallback() + +/** + * @brief A function for setting the default sleep control + * value against which all scheduled event sleep control + * values will be evaluated. This can be used to keep + * a device awake for an extended period of time by setting + * the default to EMBER_AF_STAY_AWAKE and then resetting + * the value to EMBER_AF_OK_TO_HIBERNATE once the wake + * period is complete. + */ +#define emberAfSetDefaultSleepControl(x) \ + emberAfSetDefaultSleepControlCallback(x) + +/** + * @brief A function used to retrieve the default sleep control against + * which all event sleep control values are evaluated. The + * default sleep control value is initialized to + * EMBER_AF_OK_TO_HIBERNATE but can be changed by the application + * at any time using the emberAfSetDefaultSleepControl() function. + * @return The current default sleep control value. + */ +#define emberAfGetDefaultSleepControl() \ + emberAfGetDefaultSleepControlCallback() + +/** @} END Sleep Control */ + +/** @name Messaging */ +// @{ + +/** + * @brief This function sends a ZCL response, based on the information + * that is currently in the outgoing buffer. It is expected that a complete + * ZCL message is present, including header. The application may use + * this method directly from within the message handling function + * and associated callbacks. However this will result in the + * response being sent before the APS Ack is sent which is not + * ideal. + * + * NOTE: This will overwrite the ZCL sequence number of the message + * to use the LAST received sequence number. + */ +EmberStatus emberAfSendResponse(void); + +/** + * @brief Send ZCL response with attached message sent callback + */ +EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback); + +/** + * @brief Sends multicast. + */ +EmberStatus emberAfSendMulticast(EmberMulticastId multicastId, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message); + +/** + * @brief Multicasts the message to the group in the binding table that + * matches the cluster and source endpoint in the APS frame. Note: if the + * binding table contains many matching entries, calling this API cause a + * significant amount of network traffic. Care should be taken when considering + * the effects of broadcasts in a network. + */ +EmberStatus emberAfSendMulticastToBindings(EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message); + +/** + * @brief Sends Multicast with alias with attached message sent callback + */ +EmberStatus emberAfSendMulticastWithAliasWithCallback(EmberMulticastId multicastId, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t *message, + EmberNodeId alias, + uint8_t sequence, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends multicast with attached message sent callback. + */ +EmberStatus emberAfSendMulticastWithCallback(EmberMulticastId multicastId, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends broadcast. + */ +EmberStatus emberAfSendBroadcast(EmberNodeId destination, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message); + +/** + * @brief Sends broadcast with attached message sent callback. + */ +EmberStatus emberAfSendBroadcastWithCallback(EmberNodeId destination, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends broadcast with alias with attached message sent callback. + */ +EmberStatus emberAfSendBroadcastWithAliasWithCallback(EmberNodeId destination, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t *message, + EmberNodeId alias, + uint8_t sequence, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends unicast. + */ +EmberStatus emberAfSendUnicast(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message); + +/** + * @brief Sends unicast with attached message sent callback. + */ +EmberStatus emberAfSendUnicastWithCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message, + EmberAfMessageSentFunction callback); + +/** + * @brief Unicasts the message to each remote node in the binding table that + * matches the cluster and source endpoint in the APS frame. Note: if the + * binding table contains many matching entries, calling this API cause a + * significant amount of network traffic. + */ +EmberStatus emberAfSendUnicastToBindings(EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message); + +/** + * @brief emberAfSendUnicastToBindings with attached message sent callback. + */ +EmberStatus emberAfSendUnicastToBindingsWithCallback(EmberApsFrame *apsFrame, + uint16_t messageLength, + uint8_t* message, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends interpan message. + */ +EmberStatus emberAfSendInterPan(EmberPanId panId, + const EmberEUI64 destinationLongId, + EmberNodeId destinationShortId, + EmberMulticastId multicastId, + EmberAfClusterId clusterId, + EmberAfProfileId profileId, + uint16_t messageLength, + uint8_t* messageBytes); + +/** + * @brief Sends end device binding request. + */ +EmberStatus emberAfSendEndDeviceBind(uint8_t endpoint); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. It + * will be sent as unicast to each remote node in the binding table that + * matches the cluster and source endpoint in the APS frame. Note: if the + * binding table contains many matching entries, calling this API cause a + * significant amount of network traffic. + */ +EmberStatus emberAfSendCommandUnicastToBindings(void); + +/** + * @brief emberAfSendCommandUnicastToBindings with attached message sent callback. + */ +EmberStatus emberAfSendCommandUnicastToBindingsWithCallback(EmberAfMessageSentFunction callback); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. It + * will be sent as multicast. + */ +EmberStatus emberAfSendCommandMulticast(EmberMulticastId multicastId); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. It + * will be sent as multicast. + */ +EmberStatus emberAfSendCommandMulticastWithAlias(EmberMulticastId multicastId, EmberNodeId alias, uint8_t sequence); + +/** + * @brief emberAfSendCommandMulticast with attached message sent callback. + */ +EmberStatus emberAfSendCommandMulticastWithCallback(EmberMulticastId multicastId, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. It + * will be sent as multicast to the group specified in the binding table that + * matches the cluster and source endpoint in the APS frame. Note: if the + * binding table contains many matching entries, calling this API cause a + * significant amount of network traffic. + */ +EmberStatus emberAfSendCommandMulticastToBindings(void); +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. + * It will be sent as unicast. + */ +EmberStatus emberAfSendCommandUnicast(EmberOutgoingMessageType type, + uint16_t indexOrDestination); + +/** + * @brief emberAfSendCommandUnicast with attached message sent callback. + */ +EmberStatus emberAfSendCommandUnicastWithCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. + */ +EmberStatus emberAfSendCommandBroadcast(EmberNodeId destination); + +/** + * @brief emberAfSendCommandBroadcast with attached message sent callback. + */ +EmberStatus emberAfSendCommandBroadcastWithCallback(EmberNodeId destination, + EmberAfMessageSentFunction callback); + +/** + * @brief emberAfSendCommandBroadcast from alias with attached message sent callback. + */ +EmberStatus emberAfSendCommandBroadcastWithAliasWithCallback(EmberNodeId destination, + EmberNodeId alias, + uint8_t sequence, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. + */ +EmberStatus emberAfSendCommandBroadcastWithAlias(EmberNodeId destination, + EmberNodeId alias, + uint8_t sequence); +/** + * @brief Sends the command prepared with emberAfFill.... macro. + * + * This function is used to send a command that was previously prepared + * using the emberAfFill... macros from the client command API. + * It will be sent via inter-PAN. If destinationLongId is not NULL, the message + * will be sent to that long address using long addressing mode; otherwise, the + * message will be sent to destinationShortId using short address mode. IF + * multicastId is not zero, the message will be sent using multicast mode. + */ +EmberStatus emberAfSendCommandInterPan(EmberPanId panId, + const EmberEUI64 destinationLongId, + EmberNodeId destinationShortId, + EmberMulticastId multicastId, + EmberAfProfileId profileId); + +/** + * @brief Sends a default response to a cluster command. + * + * This function is used to prepare and send a default response to a cluster + * command. + * + * @param cmd The cluster command to which to respond. + * @param status Status code for the default response command. + * @return An ::EmberStatus value that indicates the success or failure of + * sending the response. + */ +EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand *cmd, + EmberAfStatus status); + +/** + * @brief emberAfSendDefaultResponse with attached message sent callback. + */ +EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand *cmd, + EmberAfStatus status, + EmberAfMessageSentFunction callback); + +/** + * @brief Sends a default response to a cluster command using the + * current command. + * + * This function is used to prepare and send a default response to a cluster + * command. + * + * @param status Status code for the default response command. + * @return An ::EmberStatus value that indicates the success or failure of + * sending the response. + */ +EmberStatus emberAfSendImmediateDefaultResponse(EmberAfStatus status); + +/** + * @brief emberAfSendImmediateDefaultResponse with attached message sent callback. + */ +EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, + EmberAfMessageSentFunction callback); + +/** + * @brief Returns the maximum size of the payload that the Application + * Support sub-layer will accept for the given message type, destination, and + * APS frame. + * + * The size depends on multiple factors, including the security level in use + * and additional information added to the message to support the various + * options. + * + * @param type The outgoing message type. + * @param indexOrDestination Depending on the message type, this is either the + * EmberNodeId of the destination, an index into the address table, an index + * into the binding table, the multicast identifier, or a broadcast address. + * @param apsFrame The APS frame for the message. + * @return The maximum APS payload length for the given message. + */ +uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame); + +/** + * @brief Access to client API APS frame. + */ +EmberApsFrame *emberAfGetCommandApsFrame(void); + +/** + * @brief Set the source and destination endpoints in the client API APS frame. + */ +void emberAfSetCommandEndpoints(uint8_t sourceEndpoint, uint8_t destinationEndpoint); + +/** + * @brief Friendly define for use in discovering client clusters with + * ::emberAfFindDevicesByProfileAndCluster(). + */ +#define EMBER_AF_CLIENT_CLUSTER_DISCOVERY false + +/** + * @brief Friendly define for use in discovering server clusters with + * ::emberAfFindDevicesByProfileAndCluster(). + */ +#define EMBER_AF_SERVER_CLUSTER_DISCOVERY true + +/** + * @brief Use this function to find devices in the network with endpoints + * matching a given profile ID and cluster ID in their descriptors. + * Target may either be a specific device, or the broadcast + * address EMBER_RX_ON_WHEN_IDLE_BROADCAST_ADDRESS. + * + * With this function a service discovery is initiated and received + * responses are returned by executing the callback function passed in. + * For unicast discoveries, the callback will be executed only once. + * Either the target will return a result or a timeout will occur. + * For broadcast discoveries, the callback may be called multiple times + * and after a period of time the discovery will be finished with a final + * call to the callback. + * + * @param target The destination node ID for the discovery; either a specific + * node's ID or EMBER_RX_ON_WHEN_IDLE_BROADCAST_ADDRESS. + * @param profileId The application profile for the cluster being discovered. + * @param clusterId The cluster being discovered. + * @param serverCluster EMBER_AF_SERVER_CLUSTER_DISCOVERY (true) if discovering + * servers for the target cluster; EMBER_AF_CLIENT_CLUSTER_DISCOVERY (false) + * if discovering clients for that cluster. + * @param callback Function pointer for the callback function triggered when + * a match is discovered. (For broadcast discoveries, this is called once per + * matching node, even if a node has multiple matching endpoints.) + */ +EmberStatus emberAfFindDevicesByProfileAndCluster(EmberNodeId target, + EmberAfProfileId profileId, + EmberAfClusterId clusterId, + bool serverCluster, + EmberAfServiceDiscoveryCallback *callback); + +/** + * @brief Use this function to find all of the given in and out clusters + * implemented on a devices given endpoint. Target should only be the + * short address of a specific device. + * + * With this function a single service discovery is initiated and the response + * is passed back to the passed callback. + * + * @param target The destination node ID for the discovery. This should be a + * specific node's ID and should not be a broadcast address. + * @param targetEndpoint The endpoint to target with the discovery process. + * @param callback Function pointer for the callback function triggered when + * the discovery is returned. + */ +EmberStatus emberAfFindClustersByDeviceAndEndpoint(EmberNodeId target, + uint8_t targetEndpoint, + EmberAfServiceDiscoveryCallback *callback); + +/** + * @brief Use this function to initiate a discovery for the IEEE address + * of the specified node id. This will send a unicast sent to the target + * node ID. + */ +EmberStatus emberAfFindIeeeAddress(EmberNodeId shortAddress, + EmberAfServiceDiscoveryCallback *callback); + +/** + * @brief Use this function to initiate a discovery for the short ID of the + * specified long address. This will send a broadcast to all + * rx-on-when-idle devices (non-sleepies). + */ +EmberStatus emberAfFindNodeId(EmberEUI64 longAddress, + EmberAfServiceDiscoveryCallback *callback); + +/** + * @brief Initiate an Active Endpoint request ZDO message to the target node ID. + */ +EmberStatus emberAfFindActiveEndpoints(EmberNodeId target, + EmberAfServiceDiscoveryCallback *callback); + +/** + * @brief Use this function to add an entry for a remote device to the address + * table. + * + * If the EUI64 already exists in the address table, the index of the existing + * entry will be returned. Otherwise, a new entry will be created and the new + * new index will be returned. The framework will remember how many times the + * returned index has been referenced. When the address table entry is no + * longer needed, the application should remove its reference by calling + * ::emberAfRemoveAddressTableEntry. + * + * @param longId The EUI64 of the remote device. + * @param shortId The node id of the remote device or ::EMBER_UNKNOWN_NODE_ID + * if the node id is currently unknown. + * @return The index of the address table entry for this remove device or + * ::EMBER_NULL_ADDRESS_TABLE_INDEX if an error occurred (e.g., the address + * table is full). + */ +uint8_t emberAfAddAddressTableEntry(EmberEUI64 longId, EmberNodeId shortId); + +/** + * @brief Use this function to add an entry for a remote device to the address + * table at a specific location. + * + * The framework will remember how many times an address table index has been + * referenced through ::emberAfAddAddressTableEntry. If the reference count + * for the index passed to this function is not zero, the entry will be not + * changed. When the address table entry is no longer needed, the application + * should remove its reference by calling ::emberAfRemoveAddressTableEntry. + * + * @param index The index of the address table entry. + * @param longId The EUI64 of the remote device. + * @param shortId The node id of the remote device or ::EMBER_UNKNOWN_NODE_ID + * if the node id is currently unknown. + * @return ::EMBER_SUCCESS if the address table entry was successfully set, + * ::EMBER_ADDRESS_TABLE_ENTRY_IS_ACTIVE if any messages are being sent using + * the existing entry at that index or the entry is still referenced in the + * framework, or ::EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE if the index is out + * of range. + */ +EmberStatus emberAfSetAddressTableEntry(uint8_t index, + EmberEUI64 longId, + EmberNodeId shortId); + +/** + * @brief Use this function to remove a specific entry from the address table. + * + * The framework will remember how many times an address table index has been + * referenced through ::emberAfAddAddressTableEntry and + * ::emberAfSetAddressTableEntry. The address table entry at this index will + * not actually be removed until its reference count reaches zero. + * + * @param index The index of the address table entry. + * @return ::EMBER_SUCCESS if the address table entry was successfully removed + * or ::EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE if the index is out of range. + */ +EmberStatus emberAfRemoveAddressTableEntry(uint8_t index); + +#if !defined(DOXYGEN_SHOULD_SKIP_THIS) +/** + * @brief Use this macro to retrieve the current command. This + * macro may only be used within the command parsing context. For instance + * Any of the command handling callbacks may use this macro. If this macro + * is used outside the command context, the returned EmberAfClusterCommand pointer + * will be null. + */ +#define emberAfCurrentCommand() (emAfCurrentCommand) +extern EmberAfClusterCommand *emAfCurrentCommand; +#endif + +/** + * @brief returns the current endpoint that is being served. + * + * The purpose of this macro is mostly to access endpoint that + * is being served in the command callbacks. + */ +#define emberAfCurrentEndpoint() (emberAfCurrentCommand()->apsFrame->destinationEndpoint) + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** @brief Use this function to initiate key establishment with a remote node. + * ::emberAfKeyEstablishmentCallback will be called as events occur and when + * key establishment completes. + * + * @param nodeId The node id of the remote device. + * @param endpoint The endpoint on the remote device. + * @return ::EMBER_SUCCESS if key establishment was initiated successfully + */ +EmberStatus emberAfInitiateKeyEstablishment(EmberNodeId nodeId, uint8_t endpoint); + +/** @brief Use this function to initiate key establishment with a remote node on + * a different PAN. ::emberAfInterPanKeyEstablishmentCallback will be called + * as events occur and when key establishment completes. + * + * @param panId The PAN id of the remote device. + * @param eui64 The EUI64 of the remote device. + * @return ::EMBER_SUCCESS if key establishment was initiated successfully + */ +EmberStatus emberAfInitiateInterPanKeyEstablishment(EmberPanId panId, + const EmberEUI64 eui64); + +/** @brief Use this function to tell if the device is in the process of + * performing key establishment. + * + * @return ::true if key establishment is in progress. + */ +bool emberAfPerformingKeyEstablishment(void); + +/** @brief Use this function to initiate partner link key exchange with a + * remote node. + * + * @param target The node id of the remote device. + * @param endpoint The key establishment endpoint of the remote device. + * @param callback The callback that should be called when the partner link + * key exchange completes. + * @return ::EMBER_SUCCESS if the partner link key exchange was initiated + * successfully. + */ +EmberStatus emberAfInitiatePartnerLinkKeyExchange(EmberNodeId target, + uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback *callback); +#else + #define emberAfInitiateKeyEstablishment(nodeId, endpoint) \ + emberAfInitiateKeyEstablishmentCallback(nodeId, endpoint) + #define emberAfInitiateInterPanKeyEstablishment(panId, eui64) \ + emberAfInitiateInterPanKeyEstablishmentCallback(panId, eui64) + #define emberAfPerformingKeyEstablishment() \ + emberAfPerformingKeyEstablishmentCallback() + #define emberAfInitiatePartnerLinkKeyExchange(target, endpoint, callback) \ + emberAfInitiatePartnerLinkKeyExchangeCallback(target, endpoint, callback) +#endif + +/** @brief Use this function to determine if the security profile of the + * current network was set to Smart Energy. The security profile is configured + * in AppBuilder. + @ return true if the security profile is Smart Energy or false otherwise. + */ +bool emberAfIsCurrentSecurityProfileSmartEnergy(void); + +/** @} END Messaging */ + +/** @name ZCL macros */ +// @{ +// Frame control fields (8 bits total) +// Bits 0 and 1 are Frame Type Sub-field +#define ZCL_FRAME_CONTROL_FRAME_TYPE_MASK (BIT(0) | BIT(1)) +#define ZCL_CLUSTER_SPECIFIC_COMMAND BIT(0) +#define ZCL_PROFILE_WIDE_COMMAND 0 +#define ZCL_GLOBAL_COMMAND (ZCL_PROFILE_WIDE_COMMAND) +// Bit 2 is Manufacturer Specific Sub-field +#define ZCL_MANUFACTURER_SPECIFIC_MASK BIT(2) +// Bit 3 is Direction Sub-field +#define ZCL_FRAME_CONTROL_DIRECTION_MASK BIT(3) +#define ZCL_FRAME_CONTROL_SERVER_TO_CLIENT BIT(3) +#define ZCL_FRAME_CONTROL_CLIENT_TO_SERVER 0 +// Bit 4 is Disable Default Response Sub-field +#define ZCL_DISABLE_DEFAULT_RESPONSE_MASK BIT(4) +// Bits 5 to 7 are reserved + +#define ZCL_DIRECTION_CLIENT_TO_SERVER 0 +#define ZCL_DIRECTION_SERVER_TO_CLIENT 1 + +// Packet must be at least 3 bytes for ZCL overhead. +// Frame Control (1-byte) +// Sequence Number (1-byte) +// Command Id (1-byte) +#define EMBER_AF_ZCL_OVERHEAD 3 +#define EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD 5 + +// Permitted values for emberAfSetFormAndJoinMode +#define FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ BIT(0) +#define FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ BIT(1) +#define FIND_AND_JOIN_MODE_ALLOW_BOTH (FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ | FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ) + +/** @} END ZCL macros */ + +/** @name Network utility functions */ +// ${ + +/** @brief Use this function to form a new network using the specified network + * parameters. + * + * @param parameters Specification of the new network. + * @return An ::EmberStatus value that indicates either the successful formation + * of the new network or the reason that the network formation failed. + */ +EmberStatus emberAfFormNetwork(EmberNetworkParameters *parameters); + +/** @brief Use this function to associate with the network using the specified + * network parameters. + * + * @param parameters Specification of the network with which the node should + * associate. + * @return An ::EmberStatus value that indicates either that the association + * process began successfully or the reason for failure. + */ +EmberStatus emberAfJoinNetwork(EmberNetworkParameters *parameters); + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +/** @brief Use this function to find an unused PAN id and form a new network. + * + * @return An ::EmberStatus value that indicates either the process begin + * successfully or the reason for failure. + */ +EmberStatus emberAfFindUnusedPanIdAndForm(void); +/** @brief Use this function to find a joinable network and join it. + * + * @return An ::EmberStatus value that indicates either the process begin + * successfully or the reason for failure. + */ +EmberStatus emberAfStartSearchForJoinableNetwork(void); +#else + #define emberAfFindUnusedPanIdAndForm() emberAfFindUnusedPanIdAndFormCallback() + #define emberAfStartSearchForJoinableNetwork() emberAfStartSearchForJoinableNetworkCallback() +#endif + +/** @brief Sets the current network to that of the given index and adds it to + * the stack of networks maintained by the framework. Every call to this API + * must be paired with a subsequent call to ::emberAfPopNetworkIndex. + */ + +EmberStatus emberAfPushNetworkIndex(uint8_t networkIndex); +/** @brief Sets the current network to the callback network and adds it to + * the stack of networks maintained by the framework. Every call to this API + * must be paired with a subsequent call to ::emberAfPopNetworkIndex. + */ + +EmberStatus emberAfPushCallbackNetworkIndex(void); +/** @brief Sets the current network to that of the given endpoint and adds it + * to the stack of networks maintained by the framework. Every call to this + * API must be paired with a subsequent call to ::emberAfPopNetworkIndex. + */ + +EmberStatus emberAfPushEndpointNetworkIndex(uint8_t endpoint); +/** @brief Removes the topmost network from the stack of networks maintained by + * the framework and sets the current network to the new topmost network. + * Every call to this API must be paired with a prior call to + * ::emberAfPushNetworkIndex, ::emberAfPushCallbackNetworkIndex, or + * ::emberAfPushEndpointNetworkIndex. + */ + +EmberStatus emberAfPopNetworkIndex(void); +/** @brief Returns the primary endpoint of the given network index or 0xFF if + * no endpoints belong to the network. + */ + +uint8_t emberAfPrimaryEndpointForNetworkIndex(uint8_t networkIndex); +/** @brief Returns the primary endpoint of the current network index or 0xFF if + * no endpoints belong to the current network. + */ + +uint8_t emberAfPrimaryEndpointForCurrentNetworkIndex(void); + +#if !defined(DOXYGEN_SHOULD_SKIP_THIS) +/** @brief Initializes the stack of networks maintained by the framework, + * including setting the default network. + * + * @return An ::EmberStatus value that indicates either that the network stack + * has been successfully initialized or the reason for failure. + */ +EmberStatus emAfInitializeNetworkIndexStack(void); +void emAfAssertNetworkIndexStackIsEmpty(void); +#endif +/** @brief Basic initialization API to be invoked before ::emberAfMain. + */ +void emberAfMainInit(void); + +/** @brief This function effectively serves as the application main. + */ +int emberAfMain(MAIN_FUNCTION_PARAMETERS); + +/** @} End network utility functions */ + +/** @} END addtogroup */ + +#if !defined(DOXYGEN_SHOULD_SKIP_THIS) + #if defined(EMBER_TEST) + #define EMBER_TEST_ASSERT(x) assert(x) + #else + #define EMBER_TEST_ASSERT(x) + #endif +#endif + +/** @brief The maximum power level that can be used by the chip. + */ +// Note: This is a #define for now but could be a real function call in the future. +#define emberAfMaxPowerLevel() (3) + +#endif // SILABS_AF_API diff --git a/examples/wifi-echo/server/esp32/main/attribute-size.c b/examples/wifi-echo/server/esp32/main/attribute-size.c new file mode 100644 index 00000000000000..6a737b0ebe8a2c --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-size.c @@ -0,0 +1,88 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief Contains storage and function for retrieving attribute size. + ******************************************************************************* + ******************************************************************************/ + +#include PLATFORM_HEADER + +#include "af.h" + +static const uint8_t attributeSizes[] = +{ +#include "attribute-size.h" +}; + +uint8_t emberAfGetDataSize(uint8_t dataType) +{ + uint8_t i; + for (i = 0; (i + 1) < sizeof(attributeSizes); i += 2) { + if (attributeSizes[i] == dataType) { + return attributeSizes[i + 1]; + } + } + + return 0; +} + +uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, + const uint8_t *buffer) +{ + // If the dataType is a string or long string, refer to the buffer for the + // string's length prefix; size is string length plus number of prefix bytes. + // If non-string, determine size from dataType. If dataType is unrecognized, + // return zero. + // + // Note: A non-empty long string has max length 0xFFFE, and adding 2 for its + // length prefix would roll a uint16_t back to zero. Choosing not to + // expand return type to uint32_t just to accommodate that one case. + uint16_t dataSize = 0; + if (emberAfIsThisDataTypeAStringType(dataType)) { + if (buffer != 0) { + if (emberAfIsStringAttributeType(dataType)) { + // size is string length plus 1-byte length prefix + dataSize = ((uint16_t) emberAfStringLength(buffer)) + 1u; + } else { + // size is long string length plus 2-byte length prefix + dataSize = emberAfLongStringLength(buffer) + 2u; + } + } + } else { + dataSize = (uint16_t) emberAfGetDataSize(dataType); + } + + return dataSize; +} diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.c b/examples/wifi-echo/server/esp32/main/attribute-storage.c new file mode 100644 index 00000000000000..937b7deea31d0e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.c @@ -0,0 +1,1317 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief Contains the per-endpoint configuration of attribute tables. + ******************************************************************************* + ******************************************************************************/ + +#include "app/framework/include/af.h" +#include "attribute-storage.h" +#include "common.h" + +#include "znet-bookkeeping.h" + +//------------------------------------------------------------------------------ +// Globals +// This is not declared CONST in order to handle dynamic endpoint information +// retrieved from tokens. +EmberAfDefinedEndpoint emAfEndpoints[MAX_ENDPOINT_COUNT]; + +#if (ATTRIBUTE_MAX_SIZE == 0) +#define ACTUAL_ATTRIBUTE_SIZE 1 +#else +#define ACTUAL_ATTRIBUTE_SIZE ATTRIBUTE_MAX_SIZE +#endif + +uint8_t attributeData[ACTUAL_ATTRIBUTE_SIZE]; + +#if (!defined(ATTRIBUTE_SINGLETONS_SIZE)) \ + || (ATTRIBUTE_SINGLETONS_SIZE == 0) +#define ACTUAL_SINGLETONS_SIZE 1 +#else +#define ACTUAL_SINGLETONS_SIZE ATTRIBUTE_SINGLETONS_SIZE +#endif +uint8_t singletonAttributeData[ACTUAL_SINGLETONS_SIZE]; + +uint8_t emberEndpointCount = 0; + +// If we have attributes that are more than 2 bytes, then +// we need this data block for the defaults +#ifdef GENERATED_DEFAULTS +const uint8_t generatedDefaults[] = GENERATED_DEFAULTS; +#endif // GENERATED_DEFAULTS + +#ifdef GENERATED_MIN_MAX_DEFAULTS +const EmberAfAttributeMinMaxValue minMaxDefaults[] = GENERATED_MIN_MAX_DEFAULTS; +#endif //GENERATED_MIN_MAX_DEFAULTS + +#ifdef GENERATED_FUNCTION_ARRAYS +GENERATED_FUNCTION_ARRAYS +#endif + +#ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY +const EmberAfCommandMetadata generatedCommands[] = GENERATED_COMMANDS; +const EmberAfManufacturerCodeEntry commandManufacturerCodes[] = GENERATED_COMMAND_MANUFACTURER_CODES; +const uint16_t commandManufacturerCodeCount = GENERATED_COMMAND_MANUFACTURER_CODE_COUNT; +#endif + +const EmberAfAttributeMetadata generatedAttributes[] = GENERATED_ATTRIBUTES; +const EmberAfCluster generatedClusters[] = GENERATED_CLUSTERS; +const EmberAfEndpointType generatedEmberAfEndpointTypes[] = GENERATED_ENDPOINT_TYPES; +const EmAfZigbeeProNetwork emAfZigbeeProNetworks[] = EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS; + +const EmberAfManufacturerCodeEntry clusterManufacturerCodes[] = GENERATED_CLUSTER_MANUFACTURER_CODES; +const uint16_t clusterManufacturerCodeCount = GENERATED_CLUSTER_MANUFACTURER_CODE_COUNT; +const EmberAfManufacturerCodeEntry attributeManufacturerCodes[] = GENERATED_ATTRIBUTE_MANUFACTURER_CODES; +const uint16_t attributeManufacturerCodeCount = GENERATED_ATTRIBUTE_MANUFACTURER_CODE_COUNT; + +#if !defined(EMBER_SCRIPTED_TEST) +#define endpointNumber(x) fixedEndpoints[x] +#define endpointProfileId(x) fixedProfileIds[x] +#define endpointDeviceId(x) fixedDeviceIds[x] +#define endpointDeviceVersion(x) fixedDeviceVersions[x] +// Added 'Macro' to silence MISRA warning about conflict with synonymous vars. +#define endpointTypeMacro(x) (EmberAfEndpointType*)&(generatedEmberAfEndpointTypes[fixedEmberAfEndpointTypes[x]]) +#define endpointNetworkIndex(x) fixedNetworks[x] +#endif + +//------------------------------------------------------------------------------ +// Forward declarations + +// Returns endpoint index within a given cluster +static uint8_t findClusterEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t mask, uint16_t manufacturerCode); + +//------------------------------------------------------------------------------ + +// Initial configuration +void emberAfEndpointConfigure(void) +{ + uint8_t ep; + +#if !defined(EMBER_SCRIPTED_TEST) + uint8_t fixedEndpoints[] = FIXED_ENDPOINT_ARRAY; + uint16_t fixedProfileIds[] = FIXED_PROFILE_IDS; + uint16_t fixedDeviceIds[] = FIXED_DEVICE_IDS; + uint8_t fixedDeviceVersions[] = FIXED_DEVICE_VERSIONS; + uint8_t fixedEmberAfEndpointTypes[] = FIXED_ENDPOINT_TYPES; + uint8_t fixedNetworks[] = FIXED_NETWORKS; +#endif + + emberEndpointCount = FIXED_ENDPOINT_COUNT; + for ( ep = 0; ep < FIXED_ENDPOINT_COUNT; ep++ ) { + emAfEndpoints[ep].endpoint = endpointNumber(ep); + emAfEndpoints[ep].profileId = endpointProfileId(ep); + emAfEndpoints[ep].deviceId = endpointDeviceId(ep); + emAfEndpoints[ep].deviceVersion = endpointDeviceVersion(ep); + emAfEndpoints[ep].endpointType = endpointTypeMacro(ep); + emAfEndpoints[ep].networkIndex = endpointNetworkIndex(ep); + emAfEndpoints[ep].bitmask = EMBER_AF_ENDPOINT_ENABLED; + } +} + +void emberAfSetEndpointCount(uint8_t dynamicEndpointCount) +{ + emberEndpointCount = FIXED_ENDPOINT_COUNT + dynamicEndpointCount; +} + +uint8_t emberAfFixedEndpointCount(void) +{ + return FIXED_ENDPOINT_COUNT; +} + +uint8_t emberAfEndpointCount(void) +{ + return emberEndpointCount; +} + +bool emberAfEndpointIndexIsEnabled(uint8_t index) +{ + return (emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED); +} + +// some data types (like strings) are sent OTA in human readable order +// (how they are read) instead of little endian as the data types are. +bool emberAfIsThisDataTypeAStringType(EmberAfAttributeType dataType) +{ + return (dataType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE + || dataType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE + || dataType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE + || dataType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); +} + +bool emberAfIsStringAttributeType(EmberAfAttributeType attributeType) +{ + return (attributeType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE + || attributeType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE); +} + +bool emberAfIsLongStringAttributeType(EmberAfAttributeType attributeType) +{ + return (attributeType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE + || attributeType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); +} + +// This function is used to call the per-cluster default response callback +void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status, + uint8_t clientServerMask, + uint16_t manufacturerCode) +{ + EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, + clusterId, + clientServerMask, + manufacturerCode); + if (cluster != NULL) { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, + CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION); + if (f != NULL) { + emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfDefaultResponseFunction)f)(endpoint, commandId, status); + emberAfPopNetworkIndex(); + } + } +} + +// This function is used to call the per-cluster default response callback, and +// wraps the emberAfClusterDefaultResponseWithMfgCodeCallback with a +// EMBER_AF_NULL_MANUFACTURER_CODE. +void emberAfClusterDefaultResponseCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status, + uint8_t clientServerMask) +{ + emberAfClusterDefaultResponseWithMfgCodeCallback(endpoint, + clusterId, + commandId, + status, + clientServerMask, + EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// This function is used to call the per-cluster message sent callback +void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status, + uint16_t mfgCode) +{ + if (apsFrame != NULL && message != NULL && msgLen != 0) { + EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(apsFrame->sourceEndpoint, + apsFrame->clusterId, + (((message[0] + & ZCL_FRAME_CONTROL_DIRECTION_MASK) + == ZCL_FRAME_CONTROL_SERVER_TO_CLIENT) + ? CLUSTER_MASK_SERVER + : CLUSTER_MASK_CLIENT), + mfgCode); + if (cluster != NULL) { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, + CLUSTER_MASK_MESSAGE_SENT_FUNCTION); + if (f != NULL) { + emberAfPushEndpointNetworkIndex(apsFrame->sourceEndpoint); + ((EmberAfMessageSentFunction)f)(type, + indexOrDestination, + apsFrame, + msgLen, + message, + status); + emberAfPopNetworkIndex(); + } + } + } +} + +// This function is used to call the per-cluster message sent callback, and +// wraps the emberAfClusterMessageSentWithMfgCodeCallback with a +// EMBER_AF_NULL_MANUFACTURER_CODE. +void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status) +{ + emberAfClusterMessageSentWithMfgCodeCallback(type, + indexOrDestination, + apsFrame, + msgLen, + message, + status, + EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// This function is used to call the per-cluster attribute changed callback +void emAfClusterAttributeChangedCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t clientServerMask, + uint16_t manufacturerCode) +{ + EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, + clusterId, + clientServerMask, + manufacturerCode); + if (cluster != NULL) { + if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, + CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) { + emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfClusterAttributeChangedCallback)f)(endpoint, attributeId); + emberAfPopNetworkIndex(); + } + } else { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, + CLUSTER_MASK_MANUFACTURER_SPECIFIC_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) { + emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfManufacturerSpecificClusterAttributeChangedCallback)f)(endpoint, + attributeId, + manufacturerCode); + emberAfPopNetworkIndex(); + } + } + } +} + +// This function is used to call the per-cluster pre-attribute changed callback +EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t clientServerMask, + uint16_t manufacturerCode, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t* value) +{ + EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, + clusterId, + clientServerMask, + manufacturerCode); + if (cluster == NULL) { + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; + } else { + EmberAfStatus status = EMBER_ZCL_STATUS_SUCCESS; + if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, + CLUSTER_MASK_PRE_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) { + emberAfPushEndpointNetworkIndex(endpoint); + status = ((EmberAfClusterPreAttributeChangedCallback)f)(endpoint, + attributeId, + attributeType, + size, + value); + emberAfPopNetworkIndex(); + } + } + return status; + } +} + +static void initializeEndpoint(EmberAfDefinedEndpoint* definedEndpoint) +{ + uint8_t clusterIndex; + EmberAfEndpointType* epType = definedEndpoint->endpointType; + emberAfPushEndpointNetworkIndex(definedEndpoint->endpoint); + for ( clusterIndex = 0; + clusterIndex < epType->clusterCount; + clusterIndex++ ) { + EmberAfCluster *cluster = &(epType->cluster[clusterIndex]); + EmberAfGenericClusterFunction f; + emberAfClusterInitCallback(definedEndpoint->endpoint, cluster->clusterId); + f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_INIT_FUNCTION); + if ( f != NULL ) { + ((EmberAfInitFunction)f)(definedEndpoint->endpoint); + } + } + emberAfPopNetworkIndex(); +} + +// Calls the init functions. +void emAfCallInits(void) +{ + uint8_t index; + for ( index = 0; index < emberAfEndpointCount(); index++ ) { + if (emberAfEndpointIndexIsEnabled(index)) { + initializeEndpoint(&(emAfEndpoints[index])); + } + } +} + +// Returns the pointer to metadata, or null if it is not found +EmberAfAttributeMetadata *emberAfLocateAttributeMetadata(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode) +{ + EmberAfAttributeMetadata *metadata = NULL; + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = clusterId; + record.clusterMask = mask; + record.attributeId = attributeId; + record.manufacturerCode = manufacturerCode; + emAfReadOrWriteAttribute(&record, + &metadata, + NULL, // buffer + 0, // buffer size + false); // write? + return metadata; +} + +static uint8_t* singletonAttributeLocation(EmberAfAttributeMetadata *am) +{ + EmberAfAttributeMetadata *m = (EmberAfAttributeMetadata *)&(generatedAttributes[0]); + uint16_t index = 0; + while ( m < am ) { + if ((m->mask & ATTRIBUTE_MASK_SINGLETON) != 0U) { + index += m->size; + } + m++; + } + return (uint8_t *)(singletonAttributeData + index); +} + +// This function does mem copy, but smartly, which means that if the type is a +// string, it will copy as much as it can. +// If src == NULL, then this method will set memory to zeroes +static EmberAfStatus typeSensitiveMemCopy(uint8_t* dest, + uint8_t* src, + EmberAfAttributeMetadata * am, + bool write, + uint16_t readLength) +{ + EmberAfAttributeType attributeType = am->attributeType; + uint16_t size = (readLength == 0) ? am->size : readLength; + + if (emberAfIsStringAttributeType(attributeType)) { + emberAfCopyString(dest, src, size - 1); + } else if (emberAfIsLongStringAttributeType(attributeType)) { + emberAfCopyLongString(dest, src, size - 2); + } else { + if (!write && readLength != 0 && readLength < am->size) { + return EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; + } + if ( src == NULL ) { + MEMSET(dest, 0, size); + } else { + MEMMOVE(dest, src, size); + } + } + return EMBER_ZCL_STATUS_SUCCESS; +} + +// Returns the manufacturer code or ::EMBER_AF_NULL_MANUFACTURER_CODE if none +// could be found. +static uint16_t getManufacturerCode(EmberAfManufacturerCodeEntry *codes, + uint16_t codeTableSize, + uint16_t tableIndex) +{ + uint16_t i; + for (i = 0; i < codeTableSize; i++) { + if (codes->index == tableIndex) { + return codes->manufacturerCode; + } + codes++; + } + return EMBER_AF_NULL_MANUFACTURER_CODE; +} + +// This function basically wraps getManufacturerCode with the parameters +// associating an attributes metadata with its code. +uint16_t emberAfGetMfgCode(EmberAfAttributeMetadata *metadata) +{ + return getManufacturerCode((EmberAfManufacturerCodeEntry *) attributeManufacturerCodes, + attributeManufacturerCodeCount, + (metadata - generatedAttributes)); +} + +uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster *cluster, + EmberAfAttributeMetadata *attMetaData) +{ + return (emberAfClusterIsManufacturerSpecific(cluster) + ? emAfGetManufacturerCodeForCluster(cluster) + : emberAfGetMfgCode(attMetaData)); +} + +uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster *cluster) +{ + return getManufacturerCode((EmberAfManufacturerCodeEntry *)clusterManufacturerCodes, + clusterManufacturerCodeCount, + (cluster - generatedClusters)); +} + +/** + * @brief Matches a cluster based on cluster id, direction and manufacturer code. + * This function assumes that the passed cluster's endpoint already + * matches the endpoint of the EmberAfAttributeSearchRecord. + * + * Cluster's match if: + * 1. Cluster ids match AND + * 2. Cluster directions match as defined by cluster->mask + * and attRecord->clusterMask AND + * 3. If the clusters are mf specific, their mfg codes match. + */ +bool emAfMatchCluster(EmberAfCluster *cluster, + EmberAfAttributeSearchRecord *attRecord) +{ + return (cluster->clusterId == attRecord->clusterId + && cluster->mask & attRecord->clusterMask + && (!emberAfClusterIsManufacturerSpecific(cluster) + || (emAfGetManufacturerCodeForCluster(cluster) + == attRecord->manufacturerCode))); +} + +/** + * @brief Matches an attribute based on attribute id and manufacturer code. + * This function assumes that the passed cluster already matches the + * clusterId, direction and mf specificity of the passed + * EmberAfAttributeSearchRecord. + * + * Note: If both the attribute and cluster are manufacturer specific, + * the cluster's mf code gets precedence. + * + * Attributes match if: + * 1. Att ids match AND + * a. cluster IS mf specific OR + * b. both stored and saught attributes are NOT mf specific OR + * c. stored att IS mf specific AND mfg codes match. + */ +bool emAfMatchAttribute(EmberAfCluster *cluster, + EmberAfAttributeMetadata *am, + EmberAfAttributeSearchRecord *attRecord) +{ + return (am->attributeId == attRecord->attributeId + && (emberAfClusterIsManufacturerSpecific(cluster) + || (emAfGetManufacturerCodeForAttribute(cluster, am) + == attRecord->manufacturerCode))); +} + +// When reading non-string attributes, this function returns an error when destination +// buffer isn't large enough to accommodate the attribute type. For strings, the +// function will copy at most readLength bytes. This means the resulting string +// may be truncated. The length byte(s) in the resulting string will reflect +// any truncation. If readLength is zero, we are working with backwards- +// compatibility wrapper functions and we just cross our fingers and hope for +// the best. +// +// When writing attributes, readLength is ignored. For non-string attributes, +// this function assumes the source buffer is the same size as the attribute +// type. For strings, the function will copy as many bytes as will fit in the +// attribute. This means the resulting string may be truncated. The length +// byte(s) in the resulting string will reflect any truncated. +EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord *attRecord, + EmberAfAttributeMetadata **metadata, + uint8_t *buffer, + uint16_t readLength, + bool write) +{ + uint8_t i; + uint16_t attributeOffsetIndex = 0; + + for (i = 0; i < emberAfEndpointCount(); i++) { + if (emAfEndpoints[i].endpoint == attRecord->endpoint) { + EmberAfEndpointType *endpointType = emAfEndpoints[i].endpointType; + uint8_t clusterIndex; + if (!emberAfEndpointIndexIsEnabled(i)) { + continue; + } + for (clusterIndex = 0; + clusterIndex < endpointType->clusterCount; + clusterIndex++) { + EmberAfCluster *cluster = &(endpointType->cluster[clusterIndex]); + if (emAfMatchCluster(cluster, attRecord)) { // Got the cluster + uint16_t attrIndex; + for (attrIndex = 0; + attrIndex < cluster->attributeCount; + attrIndex++) { + EmberAfAttributeMetadata *am = &(cluster->attributes[attrIndex]); + if (emAfMatchAttribute(cluster, + am, + attRecord)) { // Got the attribute + // If passed metadata location is not null, populate + if (metadata != NULL) { + *metadata = am; + } + + { + uint8_t *attributeLocation = (am->mask & ATTRIBUTE_MASK_SINGLETON + ? singletonAttributeLocation(am) + : attributeData + attributeOffsetIndex); + uint8_t *src, *dst; + if (write) { + src = buffer; + dst = attributeLocation; + if (!emberAfAttributeWriteAccessCallback(attRecord->endpoint, + attRecord->clusterId, + emAfGetManufacturerCodeForAttribute(cluster, am), + am->attributeId)) { + return EMBER_ZCL_STATUS_NOT_AUTHORIZED; + } + } else { + if (buffer == NULL) { + return EMBER_ZCL_STATUS_SUCCESS; + } + + src = attributeLocation; + dst = buffer; + if (!emberAfAttributeReadAccessCallback(attRecord->endpoint, + attRecord->clusterId, + emAfGetManufacturerCodeForAttribute(cluster, am), + am->attributeId)) { + return EMBER_ZCL_STATUS_NOT_AUTHORIZED; + } + } + + return (am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE + ? (write) + ? emberAfExternalAttributeWriteCallback(attRecord->endpoint, + attRecord->clusterId, + am, + emAfGetManufacturerCodeForAttribute(cluster, am), + buffer) + : emberAfExternalAttributeReadCallback(attRecord->endpoint, + attRecord->clusterId, + am, + emAfGetManufacturerCodeForAttribute(cluster, am), + buffer, + emberAfAttributeSize(am)) + : typeSensitiveMemCopy(dst, + src, + am, + write, + readLength)); + } + } else { // Not the attribute we are looking for + // Increase the index if attribute is not externally stored + if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE) + && !(am->mask & ATTRIBUTE_MASK_SINGLETON) ) { + attributeOffsetIndex += emberAfAttributeSize(am); + } + } + } + } else { // Not the cluster we are looking for + attributeOffsetIndex += cluster->clusterSize; + } + } + } else { // Not the endpoint we are looking for + attributeOffsetIndex += emAfEndpoints[i].endpointType->endpointSize; + } + } + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; // Sorry, attribute was not found. +} + +// Check if a cluster is implemented or not. If yes, the cluster is returned. +// If the cluster is not manufacturerSpecific [ClusterId < FC00] then +// manufacturerCode argument is ignored otherwise checked. +// +// mask = 0 -> find either client or server +// mask = CLUSTER_MASK_CLIENT -> find client +// mask = CLUSTER_MASK_SERVER -> find server +EmberAfCluster *emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType *endpointType, + EmberAfClusterId clusterId, + EmberAfClusterMask mask, + uint16_t manufacturerCode) +{ + uint8_t i; + for (i = 0; i < endpointType->clusterCount; i++) { + EmberAfCluster *cluster = &(endpointType->cluster[i]); + if (cluster->clusterId == clusterId + && (mask == 0 + || (mask == CLUSTER_MASK_CLIENT && emberAfClusterIsClient(cluster)) + || (mask == CLUSTER_MASK_SERVER && emberAfClusterIsServer(cluster))) + && (!emberAfClusterIsManufacturerSpecific(cluster) + || (emAfGetManufacturerCodeForCluster(cluster) + == manufacturerCode) + // For compatibility with older stack api, we ignore manufacturer code here + // if the manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE + || manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE)) { + return cluster; + } + } + return NULL; +} + +// This functions wraps emberAfFindClusterInTypeWithMfgCode with +// a manufacturerCode of EMBER_AF_NULL_MANUFACTURER_CODE. +EmberAfCluster *emberAfFindClusterInType(EmberAfEndpointType *endpointType, + EmberAfClusterId clusterId, + EmberAfClusterMask mask) +{ + return emberAfFindClusterInTypeWithMfgCode(endpointType, + clusterId, + mask, + EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// This code is used during unit tests for clusters that do not involve manufacturer code. +// Should this code be used in other locations, manufacturerCode should be added. +uint8_t emberAfClusterIndex(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask) +{ + uint8_t ep; + uint8_t index = 0xFF; + for ( ep = 0; ep < emberAfEndpointCount(); ep++ ) { + EmberAfEndpointType *endpointType = emAfEndpoints[ep].endpointType; + if ( emberAfFindClusterInTypeWithMfgCode(endpointType, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL ) { + index++; + if ( emAfEndpoints[ep].endpoint == endpoint ) { + return index; + } + } + } + return 0xFF; +} + +// Returns true uf endpoint contains passed cluster +bool emberAfContainsClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, manufacturerCode) != NULL); +} + +// Returns true if endpoint contains passed cluster as a server +bool emberAfContainsServerWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode) != NULL); +} + +// Returns true if endpoint contains passed cluster as a client +bool emberAfContainsClientWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode) != NULL); +} + +// Wraps emberAfContainsClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +// This will find the first cluster that has the clusterId given, regardless of mfgCode. +bool emberAfContainsCluster(uint8_t endpoint, EmberAfClusterId clusterId) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); +} + +// Wraps emberAfContainsServerWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +// This will find the first server that has the clusterId given, regardless of mfgCode. +bool emberAfContainsServer(uint8_t endpoint, EmberAfClusterId clusterId) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); +} + +// Wraps emberAfContainsClientWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +// This will find the first client that has the clusterId given, regardless of mfgCode. +bool emberAfContainsClient(uint8_t endpoint, EmberAfClusterId clusterId) +{ + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); +} + +// Finds the cluster that matches endpoint, clusterId, direction, and manufacturerCode. +EmberAfCluster *emberAfFindClusterWithMfgCode(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask, + uint16_t manufacturerCode) +{ + uint8_t ep = emberAfIndexFromEndpoint(endpoint); + if ( ep == 0xFF ) { + return NULL; + } else { + return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); + } +} + +// This function wraps emberAfFindClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +// and will ignore the manufacturerCode when trying to find clusters. +// This will return the first cluster in the cluster table that matches the parameters given. +EmberAfCluster *emberAfFindCluster(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask) +{ + return emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// Returns cluster within the endpoint; Does not ignore disabled endpoints +EmberAfCluster *emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask, + uint16_t manufacturerCode) +{ + uint8_t ep = emberAfIndexFromEndpointIncludingDisabledEndpoints(endpoint); + if (ep < MAX_ENDPOINT_COUNT) { + return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); + } + return NULL; +} + +// Returns cluster within the endpoint; Does not ignore disabled endpoints +// This will ignore manufacturerCode. +EmberAfCluster *emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask) +{ + return emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// Server wrapper for findClusterEndpointIndex. +uint8_t emberAfFindClusterServerEndpointIndexWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) +{ + return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode); +} + +// Client wrapper for findClusterEndpointIndex. +uint8_t emberAfFindClusterClientEndpointIndexWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) +{ + return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode); +} + +// Server wrapper for findClusterEndpointIndex +// This will ignore manufacturerCode, and return the index for the first server that matches on clusterId +uint8_t emberAfFindClusterServerEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId) +{ + return emberAfFindClusterServerEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// Client wrapper for findClusterEndpointIndex +// This will ignore manufacturerCode, and return the index for the first client that matches on clusterId +uint8_t emberAfFindClusterClientEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId) +{ + return emberAfFindClusterClientEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// Returns the endpoint index within a given cluster +static uint8_t findClusterEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t mask, uint16_t manufacturerCode) +{ + uint8_t i, epi = 0; + + if (emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, manufacturerCode) == NULL) { + return 0xFF; + } + + for (i = 0; i < emberAfEndpointCount(); i++) { + if (emAfEndpoints[i].endpoint == endpoint) { + break; + } + epi += (emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(emAfEndpoints[i].endpoint, clusterId, mask, manufacturerCode) != NULL) ? 1 : 0; + } + + return epi; +} + +static uint8_t findIndexFromEndpoint(uint8_t endpoint, bool ignoreDisabledEndpoints) +{ + uint8_t epi; + for (epi = 0; epi < emberAfEndpointCount(); epi++) { + if (emAfEndpoints[epi].endpoint == endpoint + && (!ignoreDisabledEndpoints + || emAfEndpoints[epi].bitmask & EMBER_AF_ENDPOINT_ENABLED)) { + return epi; + } + } + return 0xFF; +} + +bool emberAfEndpointIsEnabled(uint8_t endpoint) +{ + uint8_t index = findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? + + EMBER_TEST_ASSERT(0xFF != index); + + if (0xFF == index) { + return false; + } + + return emberAfEndpointIndexIsEnabled(index); +} + +bool emberAfEndpointEnableDisable(uint8_t endpoint, bool enable) +{ + uint8_t index = findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? + bool currentlyEnabled; + + if (0xFF == index) { + return false; + } + + currentlyEnabled = emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED; + + if (enable) { + emAfEndpoints[index].bitmask |= EMBER_AF_ENDPOINT_ENABLED; + } else { + emAfEndpoints[index].bitmask &= EMBER_AF_ENDPOINT_DISABLED; + } + +#if defined(EZSP_HOST) + ezspSetEndpointFlags(endpoint, + (enable + ? EZSP_ENDPOINT_ENABLED + : EZSP_ENDPOINT_DISABLED)); +#endif + + if (currentlyEnabled != enable) { + if (enable) { + initializeEndpoint(&(emAfEndpoints[index])); + } else { + uint8_t i; + for (i = 0; i < emAfEndpoints[index].endpointType->clusterCount; i++) { + EmberAfCluster* cluster = &((emAfEndpoints[index].endpointType->cluster)[i]); +// emberAfCorePrintln("Disabling cluster tick for ep:%d, cluster:0x%2X, %p", +// endpoint, +// cluster->clusterId, +// ((cluster->mask & CLUSTER_MASK_CLIENT) +// ? "client" +// : "server")); +// emberAfCoreFlush(); + emberAfDeactivateClusterTick(endpoint, + cluster->clusterId, + (cluster->mask & CLUSTER_MASK_CLIENT + ? EMBER_AF_CLIENT_CLUSTER_TICK + : EMBER_AF_SERVER_CLUSTER_TICK)); + } + } + } + + return true; +} + +// Returns the index of a given endpoint. Does not consider disabled endpoints. +uint8_t emberAfIndexFromEndpoint(uint8_t endpoint) +{ + return findIndexFromEndpoint(endpoint, + true); // ignore disabled endpoints? +} + +// Returns the index of a given endpoint. Considers disabled endpoints. +uint8_t emberAfIndexFromEndpointIncludingDisabledEndpoints(uint8_t endpoint) +{ + return findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? +} + +uint8_t emberAfEndpointFromIndex(uint8_t index) +{ + return emAfEndpoints[index].endpoint; +} + +// If server == true, returns the number of server clusters, +// otherwise number of client clusters on this endpoint +uint8_t emberAfClusterCount(uint8_t endpoint, bool server) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + uint8_t i, c = 0; + EmberAfDefinedEndpoint *de; + EmberAfCluster *cluster; + + if ( index == 0xFF ) { + return 0; + } + de = &(emAfEndpoints[index]); + if ( de->endpointType == NULL) { + return 0; + } + for ( i = 0; i < de->endpointType->clusterCount; i++ ) { + cluster = &(de->endpointType->cluster[i]); + if ( server && emberAfClusterIsServer(cluster) ) { + c++; + } + if ( (!server) && emberAfClusterIsClient(cluster) ) { + c++; + } + } + return c; +} + +uint8_t emberAfGetClusterCountForEndpoint(uint8_t endpoint) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if ( index == 0xFF) { + return 0; + } + return emAfEndpoints[index].endpointType->clusterCount; +} + +// Note the difference in implementation from emberAfGetNthCluster(). +// emberAfGetClusterByIndex() retrieves the cluster by index regardless of server/client +// and those indexes may be DIFFERENT than the indexes returned from +// emberAfGetNthCluster(). In other words: +// +// - Use emberAfGetClustersFromEndpoint() with emberAfGetNthCluster() +// - Use emberAfGetClusterCountForEndpoint() with emberAfGetClusterByIndex() +// +// Don't mix them. +EmberAfCluster* emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex) +{ + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + EmberAfDefinedEndpoint* definedEndpoint; + + if (endpointIndex == 0xFF) { + return NULL; + } + definedEndpoint = &(emAfEndpoints[endpointIndex]); + + if (clusterIndex >= definedEndpoint->endpointType->clusterCount) { + return NULL; + } + return &(definedEndpoint->endpointType->cluster[clusterIndex]); +} + +EmberAfProfileId emberAfGetProfileIdForEndpoint(uint8_t endpoint) +{ + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + if (endpointIndex == 0xFF) { + return EMBER_AF_INVALID_PROFILE_ID; + } + return emAfEndpoints[endpointIndex].profileId; +} + +uint16_t emberAfGetDeviceIdForEndpoint(uint8_t endpoint) +{ + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + if (endpointIndex == 0xFF) { + return EMBER_AF_INVALID_PROFILE_ID; + } + return emAfEndpoints[endpointIndex].deviceId; +} + +// Returns the cluster of Nth server or client cluster, +// depending on server toggle. +EmberAfCluster *emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + EmberAfDefinedEndpoint *de; + uint8_t i, c = 0; + EmberAfCluster *cluster; + + if ( index == 0xFF ) { + return NULL; + } + de = &(emAfEndpoints[index]); + + for ( i = 0; i < de->endpointType->clusterCount; i++ ) { + cluster = &(de->endpointType->cluster[i]); + + if ( (server && emberAfClusterIsServer(cluster) ) + || ( (!server) && emberAfClusterIsClient(cluster) ) ) { + if ( c == n ) { + return cluster; + } + c++; + } + } + return NULL; +} + +// Returns number of clusters put into the passed cluster list +// for the given endpoint and client/server polarity +uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId *clusterList, uint8_t listLen, bool server) +{ + uint8_t clusterCount = emberAfClusterCount(endpoint, server); + uint8_t i; + EmberAfCluster *cluster; + if (clusterCount > listLen) { + clusterCount = listLen; + } + for (i = 0; i < clusterCount; i++) { + cluster = emberAfGetNthCluster(endpoint, i, server); + clusterList[i] = (cluster == NULL ? 0xFFFF : cluster->clusterId); + } + return clusterCount; +} + +void emberAfInitializeAttributes(uint8_t endpoint) +{ + emAfLoadAttributeDefaults(endpoint, false); +} + +void emberAfResetAttributes(uint8_t endpoint) +{ + emAfLoadAttributeDefaults(endpoint, true); + emAfResetAttributes(endpoint); +} + +void emAfLoadAttributeDefaults(uint8_t endpoint, bool writeTokens) +{ + uint8_t ep, clusterI, curNetwork = emberGetCurrentNetwork(); + uint16_t attr; + uint8_t *ptr; + uint8_t epCount = emberAfEndpointCount(); + + for ( ep = 0; ep < epCount; ep++ ) { + EmberAfDefinedEndpoint *de; + if (endpoint != EMBER_BROADCAST_ENDPOINT) { + ep = emberAfIndexFromEndpoint(endpoint); + if (ep == 0xFF) { + return; + } + } + de = &(emAfEndpoints[ep]); + + // Ensure that the endpoint is on the current network + if (endpoint == EMBER_BROADCAST_ENDPOINT + && de->networkIndex != curNetwork) { + continue; + } + for ( clusterI = 0; clusterI < de->endpointType->clusterCount; clusterI++) { + EmberAfCluster *cluster = &(de->endpointType->cluster[clusterI]); + + // when the attributeCount is high, the loop takes too long to run and a + // watchdog kicks in causing a reset. As a workaround, we'll + // conditionally manually reset the watchdog. 300 sounds like a good + // magic number for now. + if (cluster->attributeCount > 300) { + halResetWatchdog(); + } + for ( attr = 0; attr < cluster->attributeCount; attr++) { + EmberAfAttributeMetadata *am = &(cluster->attributes[attr]); + if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE)) { + EmberAfAttributeSearchRecord record; + record.endpoint = de->endpoint; + record.clusterId = cluster->clusterId; + record.clusterMask = (emberAfAttributeIsClient(am) + ? CLUSTER_MASK_CLIENT + : CLUSTER_MASK_SERVER); + record.attributeId = am->attributeId; + record.manufacturerCode = emAfGetManufacturerCodeForAttribute(cluster, + am); + if ((am->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) { + if ( emberAfAttributeSize(am) <= 2 ) { + ptr = (uint8_t*)&(am->defaultValue.ptrToMinMaxValue->defaultValue.defaultValue); + } else { + ptr = (uint8_t*)am->defaultValue.ptrToMinMaxValue->defaultValue.ptrToDefaultValue; + } + } else { + if ( emberAfAttributeSize(am) <= 2 ) { + ptr = (uint8_t*)&(am->defaultValue.defaultValue); + } else { + ptr = (uint8_t*)am->defaultValue.ptrToDefaultValue; + } + } + // At this point, ptr either points to a default value, or is NULL, in which case + // it should be treated as if it is pointing to an array of all zeroes. + +#if (BIGENDIAN_CPU) + // The default value for one- and two-byte attributes is stored in an + // uint16_t. On big-endian platforms, a pointer to the default value of + // a one-byte attribute will point to the wrong byte. So, for those + // cases, nudge the pointer forward so it points to the correct byte. + if (emberAfAttributeSize(am) == 1 && ptr != NULL) { + *ptr++; + } +#endif //BIGENDIAN + emAfReadOrWriteAttribute(&record, + NULL, // metadata - unused + ptr, + 0, // buffer size - unused + true); // write? + if (writeTokens) { + emAfSaveAttributeToToken(ptr, de->endpoint, record.clusterId, am); + } + } + } + } + if (endpoint != EMBER_BROADCAST_ENDPOINT) { + break; + } + } + + if (!writeTokens) { + emAfLoadAttributesFromTokens(endpoint); + } +} + +void emAfLoadAttributesFromTokens(uint8_t endpoint) +{ + // On EZSP host we currently do not support this. We need to come up with some + // callbacks. +#ifndef EZSP_HOST + GENERATED_TOKEN_LOADER(endpoint); +#endif // EZSP_HOST +} + +// 'data' argument may be null, since we changed the ptrToDefaultValue +// to be null instead of pointing to all zeroes. +// This function has to be able to deal with that. +void emAfSaveAttributeToToken(uint8_t *data, + uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *metadata) +{ + // Get out of here if this attribute doesn't have a token. + if ( !emberAfAttributeIsTokenized(metadata)) { + return; + } + +// On EZSP host we currently do not support this. We need to come up with some +// callbacks. +#ifndef EZSP_HOST + GENERATED_TOKEN_SAVER; +#endif // EZSP_HOST +} + +// This function returns the actual function point from the array, +// iterating over the function bits. +EmberAfGenericClusterFunction +emberAfFindClusterFunction(EmberAfCluster *cluster, + EmberAfClusterMask functionMask) +{ + EmberAfClusterMask mask = 0x01; + uint8_t functionIndex = 0; + + if ( (cluster->mask & functionMask) == 0 ) { + return NULL; + } + + while ( mask < functionMask ) { + if ( (cluster->mask & mask) != 0 ) { + functionIndex++; + } + mask <<= 1; + } + return cluster->functions[functionIndex]; +} + +#ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY + +uint16_t emAfGetManufacturerCodeForCommand(EmberAfCommandMetadata *command) +{ + return getManufacturerCode((EmberAfManufacturerCodeEntry *)commandManufacturerCodes, + commandManufacturerCodeCount, + (command - generatedCommands)); +} + +/** + * This function populates command IDs into a given buffer. + * + * It returns true if commands are complete, meaning there are NO MORE + * commands that would be returned after the last command. + * It returns false, if there were more commands, but were not populated + * because of maxIdCount limitation. + */ +bool emberAfExtractCommandIds(bool outgoing, + EmberAfClusterCommand *cmd, + uint16_t clusterId, + uint8_t *buffer, + uint16_t bufferLength, + uint16_t *bufferIndex, + uint8_t startId, + uint8_t maxIdCount) +{ + uint16_t i, count = 0; + bool returnValue = true; + uint8_t cmdDirMask = 0; + + // determine the appropriate mask to match the request + // discover commands generated, client is asking server what commands do you generate? + if (outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) { + cmdDirMask = COMMAND_MASK_OUTGOING_SERVER; + // discover commands generated server is asking client what commands do you generate? + } else if (outgoing && (cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT)) { + cmdDirMask = COMMAND_MASK_OUTGOING_CLIENT; + // discover commands received client is asking server what commands do you receive? + } else if (!outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) { + cmdDirMask = COMMAND_MASK_INCOMING_SERVER; + // discover commands received server is asking client what commands do you receive? + } else { + cmdDirMask = COMMAND_MASK_INCOMING_CLIENT; + } + + for ( i = 0; i < EMBER_AF_GENERATED_COMMAND_COUNT; i++ ) { + if ( generatedCommands[i].clusterId != clusterId ) { + continue; + } + + if ((generatedCommands[i].mask & cmdDirMask) == 0 ) { + continue; + } + + //Only start from the passed command id + if (generatedCommands[i].commandId < startId) { + continue; + } + + // According to spec: if cmd->mfgSpecific is set, then we ONLY return the + // mfg specific commands. If it's not, then we ONLY return non-mfg specific. + if ( generatedCommands[i].mask & COMMAND_MASK_MANUFACTURER_SPECIFIC ) { + // Command is Mfg specific + if ( !cmd->mfgSpecific ) { + continue; // ignore if asking for not mfg specific + } + if ( cmd->mfgCode != emAfGetManufacturerCodeForCommand( (EmberAfCommandMetadata*) &(generatedCommands[i]))) { + continue; // Ignore if mfg code doesn't match the commands + } + } else { + // Command is not mfg specific. + if ( cmd->mfgSpecific ) { + continue; // Ignore if asking for mfg specific + } + } + + // The one we are about to put in, is beyond the maxIdCount, + // so instead of populating it in, we set the return flag to + // false and get out of here. + if ( maxIdCount == count || count >= bufferLength ) { + returnValue = false; + break; + } + buffer[count] = generatedCommands[i].commandId; + (*bufferIndex)++; + count++; + } + return returnValue; +} +#else +// We just need an empty stub if we don't support it +bool emberAfExtractCommandIds(bool outgoing, + EmberAfClusterCommand *cmd, + uint16_t clusterId, + uint8_t *buffer, + uint16_t bufferLength, + uint16_t *bufferIndex, + uint8_t startId, + uint8_t maxIdCount) +{ + return true; +} +#endif diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.h b/examples/wifi-echo/server/esp32/main/attribute-storage.h new file mode 100644 index 00000000000000..b27c4b3d611d2a --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.h @@ -0,0 +1,267 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief Contains the per-endpoint configuration of attribute tables. + ******************************************************************************* + ******************************************************************************/ + +#ifndef __AF_ATTRIBUTE_STORAGE__ +#define __AF_ATTRIBUTE_STORAGE__ + +#include PLATFORM_HEADER +#include "../include/af.h" + +#if !defined (EMBER_SCRIPTED_TEST) + #include "att-storage.h" +#endif + +#if !defined(ATTRIBUTE_STORAGE_CONFIGURATION) && defined(EMBER_TEST) +#define ATTRIBUTE_STORAGE_CONFIGURATION "attribute-storage-test.h" +#endif + +// ATTRIBUTE_STORAGE_CONFIGURATION macro +// contains the file that contains the initial set-up of the +// attribute data structures. If it is missing +// we use the provider sample. +#ifndef ATTRIBUTE_STORAGE_CONFIGURATION + #error "Must define ATTRIBUTE_STORAGE_CONFIGURATION to specify the App. Builder default attributes file." +#else + #include ATTRIBUTE_STORAGE_CONFIGURATION +#endif + +// If we have fixed number of endpoints, then max is the same. +#ifdef FIXED_ENDPOINT_COUNT +#define MAX_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT +#endif + +#define CLUSTER_TICK_FREQ_ALL (0x00) +#define CLUSTER_TICK_FREQ_QUARTER_SECOND (0x04) +#define CLUSTER_TICK_FREQ_HALF_SECOND (0x08) +#define CLUSTER_TICK_FREQ_SECOND (0x0C) + +extern uint8_t attributeData[]; // main storage bucket for all attributes + +extern uint8_t attributeDefaults[]; // storage bucked for > 2b default values + +void emAfCallInits(void); + +#define emberAfClusterIsClient(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_CLIENT) != 0)) +#define emberAfClusterIsServer(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_SERVER) != 0)) +#define emberAfDoesClusterHaveInitFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_INIT_FUNCTION) != 0)) +#define emberAfDoesClusterHaveAttributeChangedFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION) != 0)) +#define emberAfDoesClusterHaveDefaultResponseFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION) != 0)) +#define emberAfDoesClusterHaveMessageSentFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_MESSAGE_SENT_FUNCTION) != 0)) + +// Initial configuration +void emberAfEndpointConfigure(void); +bool emberAfExtractCommandIds(bool outgoing, + EmberAfClusterCommand *cmd, + uint16_t clusterId, + uint8_t *buffer, + uint16_t bufferLength, + uint16_t *bufferIndex, + uint8_t startId, + uint8_t maxIdCount); + +EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord *attRecord, + EmberAfAttributeMetadata **metadata, + uint8_t *buffer, + uint16_t readLength, + bool write); + +bool emAfMatchCluster(EmberAfCluster *cluster, + EmberAfAttributeSearchRecord *attRecord); +bool emAfMatchAttribute(EmberAfCluster *cluster, + EmberAfAttributeMetadata *am, + EmberAfAttributeSearchRecord *attRecord); + +EmberAfCluster *emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType *endpointType, + EmberAfClusterId clusterId, + EmberAfClusterMask mask, + uint16_t manufacturerCode); + +EmberAfCluster *emberAfFindClusterInType(EmberAfEndpointType *endpointType, + EmberAfClusterId clusterId, + EmberAfClusterMask mask); + +// This function returns the index of cluster for the particular endpoint. +// Mask is either CLUSTER_MASK_CLIENT or CLUSTER_MASK_SERVER +// For example, if you have 3 endpoints, 10, 11, 12, and cluster X server is +// located on 11 and 12, and cluster Y server is located only on 10 then +// clusterIndex(X,11,CLUSTER_MASK_SERVER) returns 0, +// clusterIndex(X,12,CLUSTER_MASK_SERVER) returns 1, +// clusterIndex(X,10,CLUSTER_MASK_SERVER) returns 0xFF +// clusterIndex(Y,10,CLUSTER_MASK_SERVER) returns 0 +// clusterIndex(Y,11,CLUSTER_MASK_SERVER) returns 0xFF +// clusterIndex(Y,12,CLUSTER_MASK_SERVER) returns 0xFF +uint8_t emberAfClusterIndex(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask); + +// If server == true, returns the number of server clusters, +// otherwise number of client clusters on this endpoint +uint8_t emberAfClusterCount(uint8_t endpoint, bool server); + +// Returns the clusterId of Nth server or client cluster, +// depending on server toggle. +EmberAfCluster *emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server); + +// Returns number of clusters put into the passed cluster list +// for the given endpoint and client/server polarity +uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId *clusterList, uint8_t listLen, bool server); + +// Returns cluster within the endpoint, or NULL if it isn't there +EmberAfCluster *emberAfFindClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask, uint16_t manufacturerCode); + +// Returns cluster within the endpoint, or NULL if it isn't there +// This wraps emberAfFindClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +EmberAfCluster *emberAfFindCluster(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask); + +// Returns cluster within the endpoint; Does not ignore disabled endpoints +EmberAfCluster *emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask, + uint16_t manufacturerCode); + +// Returns cluster within the endpoint; Does not ignore disabled endpoints +// This wraps emberAfFindClusterIncludingDisabledEndpointsWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE +EmberAfCluster *emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfClusterMask mask); + +// Function mask must contain one of the CLUSTER_MASK function macros, +// then this method either returns the function pointer or null if +// function doesn't exist. Before you call the function, you must +// cast it. +EmberAfGenericClusterFunction emberAfFindClusterFunction(EmberAfCluster *cluster, EmberAfClusterMask functionMask); + +// Public APIs for loading attributes +void emberAfInitializeAttributes(uint8_t endpoint); +void emberAfResetAttributes(uint8_t endpoint); + +// Loads the attributes from built-in default and / or tokens +void emAfLoadAttributeDefaults(uint8_t endpoint, bool writeTokens); + +// This function loads from tokens all the attributes that +// are defined to be stored in tokens. +void emAfLoadAttributesFromTokens(uint8_t endpoint); + +// After the RAM value has changed, code should call this +// function. If this attribute has been +// tagged as stored-to-token, then code will store +// the attribute to token. +void emAfSaveAttributeToToken(uint8_t *data, + uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *metadata); + +// Calls the attribute changed callback +void emAfClusterAttributeChangedCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t clientServerMask, + uint16_t manufacturerCode); + +// Calls the attribute changed callback for a specific cluster. +EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t clientServerMask, + uint16_t manufacturerCode, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t* value); + +// Calls the default response callback for a specific cluster, and wraps emberAfClusterDefaultResponseWithMfgCodeCallback +// with the EMBER_NULL_MANUFACTURER_CODE +void emberAfClusterDefaultResponseCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status, + uint8_t clientServerMask); + +// Calls the default response callback for a specific cluster. +void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status, + uint8_t clientServerMask, + uint16_t manufacturerCode); + +// Calls the message sent callback for a specific cluster, and wraps emberAfClusterMessageSentWithMfgCodeCallback +void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); + +// Calls the message sent callback for a specific cluster. +void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status, + uint16_t manufacturerCode); + +// Used to retrieve a manufacturer code from an attribute metadata +uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster *cluster); +uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster *cluster, + EmberAfAttributeMetadata *attMetaData); + +// Checks a cluster mask byte against ticks passed bitmask +// returns true if the mask matches a passed interval +bool emberAfCheckTick(EmberAfClusterMask mask, + uint8_t passedMask); + +bool emberAfEndpointIsEnabled(uint8_t endpoint); + +// Note the difference in implementation from emberAfGetNthCluster(). +// emberAfGetClusterByIndex() retrieves the cluster by index regardless of server/client +// and those indexes may be DIFFERENT than the indexes returned from +// emberAfGetNthCluster(). In other words: +// +// - Use emberAfGetClustersFromEndpoint() with emberAfGetNthCluster() +// - Use emberAfGetClusterCountForEndpoint() with emberAfGetClusterByIndex() +// +// Don't mix them. +uint8_t emberAfGetClusterCountForEndpoint(uint8_t endpoint); +EmberAfCluster* emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex); + +EmberAfProfileId emberAfGetProfileIdForEndpoint(uint8_t endpoint); +uint16_t emberAfGetDeviceIdForEndpoint(uint8_t endpoint); + +#endif // __AF_ATTRIBUTE_STORAGE__ diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.c b/examples/wifi-echo/server/esp32/main/attribute-table.c new file mode 100644 index 00000000000000..65dd532f2dd72d --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-table.c @@ -0,0 +1,826 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains the code to manipulate the Smart Energy attribute + * table. This handles external calls to read/write the table, as + * well as internal ones. + ******************************************************************************* + ******************************************************************************/ + +// this file contains all the common includes for clusters in the zcl-util +#include "common.h" + +#include "attribute-storage.h" + +// for pulling in defines dealing with EITHER server or client +#include "af-main.h" + +#include "enums.h" + +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// External Declarations + +//------------------------------------------------------------------------------ +// Forward Declarations + +//------------------------------------------------------------------------------ +// Globals + +EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + EmberAfAttributeWritePermission extWritePermission + = emberAfAllowNetworkWriteAttributeCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataPtr, + dataType); + switch (extWritePermission) { + case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_DENY_WRITE: + return EMBER_ZCL_STATUS_FAILURE; + case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL: + case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY: + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataPtr, + dataType, + (extWritePermission + == EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY), + false); + default: + return (EmberAfStatus)extWritePermission; + } +} + +//@deprecated use emberAfWriteServerAttribute or emberAfWriteClientAttribute +EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + mask, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + dataType, + true, // override read-only? + false); // just test? +} + +EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_CLIENT, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + dataType, + true, // override read-only? + false); // just test? +} + +EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_SERVER, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + dataType, + true, // override read-only? + false); // just test? +} + +EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_CLIENT, + manufacturerCode, + dataPtr, + dataType, + true, // override read-only? + false); // just test? +} + +EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_SERVER, + manufacturerCode, + dataPtr, + dataType, + true, // override read-only? + false); // just test? +} + +EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType) +{ + return emAfWriteAttribute(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataPtr, + dataType, + false, // override read-only? + true); // just test? +} + +EmberAfStatus emberAfReadAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint8_t *dataPtr, + uint8_t readLength, + EmberAfAttributeType *dataType) +{ + return emAfReadAttribute(endpoint, + cluster, + attributeID, + mask, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + readLength, + dataType); +} + +EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + uint8_t readLength) +{ + return emAfReadAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_SERVER, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + readLength, + NULL); +} + +EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t* dataPtr, + uint8_t readLength) +{ + return emAfReadAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_CLIENT, + EMBER_AF_NULL_MANUFACTURER_CODE, + dataPtr, + readLength, + NULL); +} + +EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + uint8_t readLength) +{ + return emAfReadAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_SERVER, + manufacturerCode, + dataPtr, + readLength, + NULL); +} + +EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint16_t manufacturerCode, + uint8_t* dataPtr, + uint8_t readLength) +{ + return emAfReadAttribute(endpoint, + cluster, + attributeID, + CLUSTER_MASK_CLIENT, + manufacturerCode, + dataPtr, + readLength, + NULL); +} + +bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId startAttributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t maxAttributeIds, + bool includeAccessControl) +{ + uint16_t i; + uint16_t discovered = 0; + uint16_t skipped = 0; + uint16_t total = 0; + + EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, + clusterId, + mask, + manufacturerCode); + + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = clusterId; + record.clusterMask = mask; + record.attributeId = startAttributeId; + record.manufacturerCode = manufacturerCode; + + // If we don't have the cluster or it doesn't match the search, we're done. + if (cluster == NULL || !emAfMatchCluster(cluster, &record)) { + return true; + } + + for (i = 0; i < cluster->attributeCount; i++) { + EmberAfAttributeMetadata *metadata = &cluster->attributes[i]; + + // If the cluster is not manufacturer-specific, an attribute is considered + // only if its manufacturer code matches that of the command (which may be + // unset). + if (!emberAfClusterIsManufacturerSpecific(cluster)) { + record.attributeId = metadata->attributeId; + if (!emAfMatchAttribute(cluster, metadata, &record)) { + continue; + } + } + + if (metadata->attributeId < startAttributeId) { + skipped++; + } else if (discovered < maxAttributeIds) { + emberAfPutInt16uInResp(metadata->attributeId); + emberAfPutInt8uInResp(metadata->attributeType); + if (includeAccessControl) { + // bit 0 : Readable <-- All our attributes are readable + // bit 1 : Writable <-- The only thing we track in the attribute metadata mask + // bit 2 : Reportable <-- All our attributes are reportable + emberAfPutInt8uInResp((metadata->mask & ATTRIBUTE_MASK_WRITABLE) + ? 0x07 + : 0x05); + } + discovered++; + } else { + // MISRA requires ..else if.. to have terminating else. + } + total++; + } + + // We are finished if there are no more attributes to find, which means the + // number of attributes discovered plus the number skipped equals the total + // attributes in the cluster. For manufacturer-specific clusters, the total + // includes all attributes in the cluster. For standard ZCL clusters, if the + // the manufacturer code is set, the total is the number of attributes that + // match the manufacturer code. Otherwise, the total is the number of + // standard ZCL attributes in the cluster. + return (discovered + skipped == total); +} + +static void emberAfAttributeDecodeAndPrintCluster(EmberAfClusterId cluster, uint16_t mfgCode) +{ +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) + uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); + if (index != 0xFFFF) { + emberAfAttributesPrintln("(%p)", zclClusterNames[index].name); + } + emberAfAttributesFlush(); +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) +} + +void emberAfPrintAttributeTable(void) +{ + uint8_t data[ATTRIBUTE_LARGEST]; + uint8_t endpointIndex, clusterIndex; + uint16_t attributeIndex; + EmberAfStatus status; + uint16_t mfgCode; + for (endpointIndex = 0; + endpointIndex < emberAfEndpointCount(); + endpointIndex++) { + EmberAfDefinedEndpoint *ep = &(emAfEndpoints[endpointIndex]); + emberAfAttributesPrintln("ENDPOINT %x", ep->endpoint); + emberAfAttributesPrintln("clus / side / attr / mfg /type(len)/ rw / storage / data (raw)"); + emberAfAttributesFlush(); + for (clusterIndex = 0; + clusterIndex < ep->endpointType->clusterCount; + clusterIndex++) { + EmberAfCluster *cluster = &(ep->endpointType->cluster[clusterIndex]); + + for (attributeIndex = 0; + attributeIndex < cluster->attributeCount; + attributeIndex++) { + EmberAfAttributeMetadata *metaData = &(cluster->attributes[attributeIndex]); + + // Depending on user config, this loop can take a very long time to + // run and watchdog reset will kick in. As a workaround, we'll + // manually reset the watchdog. + halResetWatchdog(); + + emberAfAttributesPrint("%2x / %p / %2x / ", + cluster->clusterId, + (emberAfAttributeIsClient(metaData) ? "clnt" : "srvr"), + metaData->attributeId); + mfgCode = emAfGetManufacturerCodeForAttribute(cluster, metaData); + if (mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) { + emberAfAttributesPrint("----"); + } else { + emberAfAttributesPrint("%2x", mfgCode); + } + emberAfAttributesPrint(" / %x (%x) / %p / %p / ", + metaData->attributeType, + emberAfAttributeSize(metaData), + (emberAfAttributeIsReadOnly(metaData) ? "RO" : "RW"), + (emberAfAttributeIsTokenized(metaData) + ? " token " + : (emberAfAttributeIsExternal(metaData) + ? "extern " + : " RAM "))); + emberAfAttributesFlush(); + status = emAfReadAttribute(ep->endpoint, + cluster->clusterId, + metaData->attributeId, + (emberAfAttributeIsClient(metaData) + ? CLUSTER_MASK_CLIENT + : CLUSTER_MASK_SERVER), + mfgCode, + data, + ATTRIBUTE_LARGEST, + NULL); + if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) { + emberAfAttributesPrintln("Unsupported"); + } else { + uint16_t length; + if (emberAfIsStringAttributeType(metaData->attributeType)) { + length = emberAfStringLength(data) + 1; + } else if (emberAfIsLongStringAttributeType(metaData->attributeType)) { + length = emberAfLongStringLength(data) + 2; + } else { + length = emberAfAttributeSize(metaData); + } + UNUSED_VAR(length); + emberAfAttributesPrintBuffer(data, length, true); + emberAfAttributesFlush(); + emberAfAttributeDecodeAndPrintCluster(cluster->clusterId, mfgCode); + } + } + } + emberAfAttributesFlush(); + } +} + +// given a clusterId and an attribute to read, this crafts the response +// and places it in the response buffer. Response is one of two items: +// 1) unsupported: [attrId:2] [status:1] +// 2) supported: [attrId:2] [status:1] [type:1] [data:n] +// +void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attrId, + uint8_t mask, + uint16_t manufacturerCode, + uint16_t readLength) +{ + EmberAfStatus status; + uint8_t data[ATTRIBUTE_LARGEST]; + uint8_t dataType; + uint16_t dataLen; + + // account for at least one byte of data + if (readLength < 5) { + return; + } + + emberAfAttributesPrintln("OTA READ: ep:%x cid:%2x attid:%2x msk:%x mfcode:%2x", + endpoint, + clusterId, attrId, mask, manufacturerCode); + + // lookup the attribute in our table + status = emAfReadAttribute(endpoint, + clusterId, + attrId, + mask, + manufacturerCode, + data, + ATTRIBUTE_LARGEST, + &dataType); + if (status == EMBER_ZCL_STATUS_SUCCESS) { + dataLen = emberAfAttributeValueSize(dataType, data); + if ((readLength - 4) < dataLen) { // Not enough space for attribute. + return; + } + } else { + emberAfPutInt16uInResp(attrId); + emberAfPutInt8uInResp(status); + emberAfAttributesPrintln("READ: clus %2x, attr %2x failed %x", + clusterId, + attrId, + status); + emberAfAttributesFlush(); + return; + } + + // put attribute in least sig byte first + emberAfPutInt16uInResp(attrId); + + // attribute is found, so copy in the status and the data type + emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); + emberAfPutInt8uInResp(dataType); + + if (dataLen < (EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength)) { +#if (BIGENDIAN_CPU) + // strings go over the air as length byte and then in human + // readable format. These should not be flipped. Other attributes + // need to be flipped so they go little endian OTA + if (isThisDataTypeSentLittleEndianOTA(dataType)) { + uint8_t i; + for (i = 0; i < dataLen; i++) { + appResponseData[appResponseLength + i] = data[dataLen - i - 1]; + } + } else { + MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); + } +#else //(BIGENDIAN_CPU) + MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); +#endif //(BIGENDIAN_CPU) + appResponseLength += dataLen; + } + + emberAfAttributesPrintln("READ: clus %2x, attr %2x, dataLen: %x, OK", + clusterId, + attrId, + dataLen); + emberAfAttributesFlush(); +} + +// This function appends the attribute report fields for the given endpoint, +// cluster, and attribute to the buffer starting at the index. If there is +// insufficient space in the buffer or an error occurs, buffer and bufIndex will +// remain unchanged. Otherwise, bufIndex will be incremented appropriately and +// the fields will be written to the buffer. +EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint8_t *buffer, + uint8_t bufLen, + uint8_t *bufIndex) +{ + EmberAfStatus status; + EmberAfAttributeType type; + uint16_t size; + uint16_t bufLen16 = (uint16_t) bufLen; + uint8_t data[ATTRIBUTE_LARGEST]; + + status = emberAfReadAttribute(endpoint, + clusterId, + attributeId, + mask, + data, + sizeof(data), + &type); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + goto kickout; + } + + size = emberAfAttributeValueSize(type, data); + if (bufLen16 - *bufIndex < 3 || size > bufLen16 - (*bufIndex + 3)) { + status = EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; + goto kickout; + } + + buffer[(*bufIndex)++] = LOW_BYTE(attributeId); + buffer[(*bufIndex)++] = HIGH_BYTE(attributeId); + buffer[(*bufIndex)++] = type; +#if (BIGENDIAN_CPU) + if (isThisDataTypeSentLittleEndianOTA(type)) { + emberReverseMemCopy(buffer + *bufIndex, data, size); + } else { + MEMMOVE(buffer + *bufIndex, data, size); + } +#else + MEMMOVE(buffer + *bufIndex, data, size); +#endif + *bufIndex += size; + + kickout: + emberAfAttributesPrintln("REPORT: clus 0x%2x, attr 0x%2x: 0x%x", + clusterId, + attributeId, + status); + emberAfAttributesFlush(); + + return status; +} + +//------------------------------------------------------------------------------ +// Internal Functions + +// writes an attribute (identified by clusterID and attrID to the given value. +// this returns: +// - EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE: if attribute isnt supported by the device (the +// device is not found in the attribute table) +// - EMBER_ZCL_STATUS_INVALID_DATA_TYPE: if the data type passed in doesnt match the type +// stored in the attribute table +// - EMBER_ZCL_STATUS_READ_ONLY: if the attribute isnt writable +// - EMBER_ZCL_STATUS_INVALID_VALUE: if the value is set out of the allowable range for +// the attribute +// - EMBER_ZCL_STATUS_SUCCESS: if the attribute was found and successfully written +// +// if true is passed in for overrideReadOnlyAndDataType then the data type is +// not checked and the read-only flag is ignored. This mode is meant for +// testing or setting the initial value of the attribute on the device. +// +// if true is passed for justTest, then the type is not written but all +// checks are done to see if the type could be written +// reads the attribute specified, returns false if the attribute is not in +// the table or the data is too large, returns true and writes to dataPtr +// if the attribute is supported and the readLength specified is less than +// the length of the data. +EmberAfStatus emAfWriteAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t *data, + EmberAfAttributeType dataType, + bool overrideReadOnlyAndDataType, + bool justTest) +{ + EmberAfAttributeMetadata *metadata = NULL; + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = cluster; + record.clusterMask = mask; + record.attributeId = attributeID; + record.manufacturerCode = manufacturerCode; + emAfReadOrWriteAttribute(&record, + &metadata, + NULL, // buffer + 0, // buffer size + false); // write? + + // if we dont support that attribute + if (metadata == NULL) { + emberAfAttributesPrintln("%pep %x clus %2x attr %2x not supported", + "WRITE ERR: ", + endpoint, + cluster, + attributeID); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; + } + + // if the data type specified by the caller is incorrect + if (!(overrideReadOnlyAndDataType)) { + if (dataType != metadata->attributeType) { + emberAfAttributesPrintln("%pinvalid data type", "WRITE ERR: "); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_INVALID_DATA_TYPE; + } + + if (emberAfAttributeIsReadOnly(metadata)) { + emberAfAttributesPrintln("%pattr not writable", "WRITE ERR: "); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_READ_ONLY; + } + } + + // if the value the attribute is being set to is out of range + // return EMBER_ZCL_STATUS_INVALID_VALUE + if ((metadata->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) { + EmberAfDefaultAttributeValue minv = metadata->defaultValue.ptrToMinMaxValue->minValue; + EmberAfDefaultAttributeValue maxv = metadata->defaultValue.ptrToMinMaxValue->maxValue; + bool isAttributeSigned = emberAfIsTypeSigned(metadata->attributeType); + uint8_t dataLen = emberAfAttributeSize(metadata); + if (dataLen <= 2) { + int8_t minR, maxR; + uint8_t* minI = (uint8_t*)&(minv.defaultValue); + uint8_t* maxI = (uint8_t*)&(maxv.defaultValue); + //On big endian cpu with length 1 only the second byte counts + #if (BIGENDIAN_CPU) + if (dataLen == 1) { + minI++; + maxI++; + } + #endif //BIGENDIAN_CPU + minR = emberAfCompareValues(minI, data, dataLen, isAttributeSigned); + maxR = emberAfCompareValues(maxI, data, dataLen, isAttributeSigned); + if ((minR == 1) || (maxR == -1)) { + return EMBER_ZCL_STATUS_INVALID_VALUE; + } + } else { + if ((emberAfCompareValues(minv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == 1) + || (emberAfCompareValues(maxv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == -1)) { + return EMBER_ZCL_STATUS_INVALID_VALUE; + } + } + } + + // write the data unless this is only a test + if (!justTest) { + // Pre write attribute callback for all attribute changes, + // regardless of cluster. + EmberAfStatus status + = emberAfPreAttributeChangeCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataType, + emberAfAttributeSize(metadata), + data); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + return status; + } + + // Pre-write attribute callback specific + // to the cluster that the attribute lives in. + status = emAfClusterPreAttributeChangedCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataType, + emberAfAttributeSize(metadata), + data); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + return status; + } + + // write the attribute + status = emAfReadOrWriteAttribute(&record, + NULL, // metadata + data, + 0, // buffer size - unused + true); // write? + + if (status != EMBER_ZCL_STATUS_SUCCESS) { + return status; + } + + // Save the attribute to token if needed + // Function itself will weed out tokens that are not tokenized. + emAfSaveAttributeToToken(data, endpoint, cluster, metadata); + + emberAfReportingAttributeChangeCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataType, + data); + + // Post write attribute callback for all attributes changes, regardless + // of cluster. + emberAfPostAttributeChangeCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode, + dataType, + emberAfAttributeSize(metadata), + data); + + // Post-write attribute callback specific + // to the cluster that the attribute lives in. + emAfClusterAttributeChangedCallback(endpoint, + cluster, + attributeID, + mask, + manufacturerCode); + } else { + // bug: 11618, we are not handling properly external attributes + // in this case... We need to do something. We don't really + // know if it will succeed. + emberAfAttributesPrintln("WRITE: no write, just a test"); + emberAfAttributesFlush(); + } + + return EMBER_ZCL_STATUS_SUCCESS; +} + +// If dataPtr is NULL, no data is copied to the caller. +// readLength should be 0 in that case. + +EmberAfStatus emAfReadAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t *dataPtr, + uint16_t readLength, + EmberAfAttributeType *dataType) +{ + EmberAfAttributeMetadata *metadata = NULL; + EmberAfAttributeSearchRecord record; + EmberAfStatus status; + record.endpoint = endpoint; + record.clusterId = cluster; + record.clusterMask = mask; + record.attributeId = attributeID; + record.manufacturerCode = manufacturerCode; + status = emAfReadOrWriteAttribute(&record, + &metadata, + dataPtr, + readLength, + false); // write? + + if (status == EMBER_ZCL_STATUS_SUCCESS) { + // It worked! If the user asked for the type, set it before returning. + if (dataType != NULL) { + (*dataType) = metadata->attributeType; + } + } else { // failed, print debug info + if (status == EMBER_ZCL_STATUS_INSUFFICIENT_SPACE) { + emberAfAttributesPrintln("READ: attribute size too large for caller"); + emberAfAttributesFlush(); + } + } + + return status; +} diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.h b/examples/wifi-echo/server/esp32/main/attribute-table.h new file mode 100644 index 00000000000000..ec93dc5cfd79e8 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-table.h @@ -0,0 +1,99 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains the definitions for the attribute table, its + * sizes, count, and API. + ******************************************************************************* + ******************************************************************************/ + +#ifndef ZCL_UTIL_ATTRIBUTE_TABLE_H +#define ZCL_UTIL_ATTRIBUTE_TABLE_H + +#include "../include/af.h" + +#define ZCL_NULL_ATTRIBUTE_TABLE_INDEX 0xFFFF + +// Remote devices writing attributes of local device +EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* dataPtr, + EmberAfAttributeType dataType); + +void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attrId, + uint8_t mask, + uint16_t manufacturerCode, + uint16_t readLength); +EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint8_t *buffer, + uint8_t bufLen, + uint8_t *bufIndex); +void emberAfPrintAttributeTable(void); + +bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId startAttributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t maxAttributeIds, + bool includeAccessControl); + +EmberAfStatus emAfWriteAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* data, + EmberAfAttributeType dataType, + bool overrideReadOnlyAndDataType, + bool justTest); + +EmberAfStatus emAfReadAttribute(uint8_t endpoint, + EmberAfClusterId cluster, + EmberAfAttributeId attributeID, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* dataPtr, + uint16_t readLength, + EmberAfAttributeType* dataType); + +#endif // ZCL_UTIL_ATTRIBUTE_TABLE_H diff --git a/examples/wifi-echo/server/esp32/main/client-api.h b/examples/wifi-echo/server/esp32/main/client-api.h new file mode 100644 index 00000000000000..a1ff750554dc3d --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/client-api.h @@ -0,0 +1,195 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief API for generating command buffer. + ******************************************************************************* + ******************************************************************************/ + +#ifndef __CLIENT_API__ +#define __CLIENT_API__ +/* + @addtogroup command + @{ + */ + +/** @name Client API functions */ +// @{ + +/** + * @brief Function that fills in the buffer with command. + * + * Fills the outgoing ZCL buffer and returns the number + * of bytes used in a buffer. Uses the buffers that + * were previously set with emberAfSetExternalBuffer. + * + * @param frameControl Byte used for frame control. + * @param clusterId Cluster ID of message. + * @param commandId Command ID of message. + * @param format String format for further arguments to the function. + * Format values are: + * - '0' - '9' and 'A' - 'G': Pointer to a buffer containing 0--16 raw + * bytes. The data is copied as is to the destination buffer. + * - 'u': uint8_t. + * - 'v': uint16_t. The bytes are copied in little-endian format to the + * destination buffer. + * - 'x': int24u. The bytes are copied in little-endian format to the + * destination buffer. + * - 'w': uint32_t. The bytes are copied in little-endian format to the + * destination buffer. + * - 'l': Pointer to a buffer containing a ZigBee long string, with the + * first two bytes of the buffer specifying the length of the string + * data in little-endian format. The length bytes and the string + * itself are both included as is in the destination buffer. + * - 's': Pointer to a buffer containing a ZigBee string, with the first + * byte of the buffer specifying the length of the string data. The + * length byte and the string itself are both included as is in the + * destination buffer. + * - 'L': Pointer to a buffer containing a long string followed by an + * uint16_t specifying the length of the string data. The length + * bytes in little-endian format will precede the string itself in + * the destination buffer. + * - 'S': Pointer to a buffer containing a string followed by an uint8_t + * specifying the length of the string data. The length byte will + * precede the string itself in the destination buffer. + * - 'b': Pointer to a buffer containing a sequence of raw bytes followed + * by an uint16_t specifying the length of the data. The data is + * copied as is to the destination buffer. The length is not + * included. + */ +uint16_t emberAfFillExternalBuffer(uint8_t frameControl, + EmberAfClusterId clusterId, + uint8_t commandId, + const char * format, + ...); + +/** + * @brief Function that fills in the buffer with manufacturer-specific command. + * + * Fills the outgoing ZCL buffer and returns the number + * of bytes used in a buffer. Uses the buffers that + * were previously set with emberAfSetExternalBuffer. + * + * @param frameControl Byte used for frame control. + * @param clusterId Cluster ID of message. + * @param manufacturerCode Manufacturer code of message. + * @param commandId Command ID of message. + * @param format String format for further arguments to the function. + * Format values are: + * - '0' -- '9' and 'A' -- 'G': Pointer to a buffer containing 0--16 raw + * bytes. The data is copied as is to the destination buffer. + * - 'u': uint8_t. + * - 'v': uint16_t. The bytes are copied in little-endian format to the + * destination buffer. + * - 'x': int24u. The bytes are copied in little-endian format to the + * destination buffer. + * - 'w': uint32_t. The bytes are copied in little-endian format to the + * destination buffer. + * - 'l': Pointer to a buffer containing a ZigBee long string, with the + * first two bytes of the buffer specifying the length of the string + * data in little-endian format. The length bytes and the string + * itself are both included as is in the destination buffer. + * - 's': Pointer to a buffer containing a ZigBee string, with the first + * byte of the buffer specifying the length of the string data. The + * length byte and the string itself are both included as is in the + * destination buffer. + * - 'L': Pointer to a buffer containing a long string followed by an + * uint16_t specifying the length of the string data. The length + * bytes in little-endian format will precede the string itself in + * the destination buffer. + * - 'S': Pointer to a buffer containing a string followed by an uint8_t + * specifying the length of the string data. The length byte will + * precede the string itself in the destination buffer. + * - 'b': Pointer to a buffer containing a sequence of raw bytes followed + * by an uint16_t specifying the length of the data. The data is + * copied as is to the destination buffer. The length is not + * included. + */ +uint16_t emberAfFillExternalManufacturerSpecificBuffer(uint8_t frameControl, + EmberAfClusterId clusterId, + uint16_t manufacturerCode, + uint8_t commandId, + const char * format, + ...); + +/** + * @brief Function that registers the buffer to use with the fill function. + * Registers the buffer for use with the emberAfFillExternalBuffer function. + * + * @param buffer Main buffer for constructing message. + * @param bufferLen Available length of buffer. + * @param responseLengthPtr Location where length of message will be written into. + * @param apsFramePtr Location where APS frame data will be written. + */ +void emberAfSetExternalBuffer(uint8_t *buffer, + uint16_t bufferLen, + uint16_t *responseLengthPtr, + EmberApsFrame *apsFramePtr); + +/** + * @brief Stateless function that fills the passed buffer with command data. + * + * Stateless method, that fill the passed buffer. + * Used internally by emberAfFillExternalBuffer, but can be used + * for generic buffer filling. + */ +uint16_t emberAfFillBuffer(uint8_t *buffer, + uint16_t bufferLen, + uint8_t frameControl, + uint8_t commandId, + const char * format, + ...); + +#if !defined(DOXYGEN_SHOULD_SKIP_THIS) +// The buffer used for filling ZCL Messages. +extern uint8_t *emAfZclBuffer; +// Max length of the buffer. +extern uint16_t emAfZclBufferLen; +// Pointer to where this API should put the length. +extern uint16_t *emAfResponseLengthPtr; +// The APS frame accompanying the ZCL message. +extern EmberApsFrame *emAfCommandApsFrame; +#endif + +// Generated macros. +#include "client-command-macro.h" + +#define emberAfAppendToExternalBuffer(...) emberAfPutBlockInResp(__VA_ARGS__) + +/** @} END Client API functions */ + +/** @} END addtogroup + */ + +#endif // __CLIENT_API__ diff --git a/examples/wifi-echo/server/esp32/main/common.h b/examples/wifi-echo/server/esp32/main/common.h new file mode 100644 index 00000000000000..09924857c2d2cd --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/common.h @@ -0,0 +1,57 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains the includes that are common to all clusters + * in the util. + ******************************************************************************* + ******************************************************************************/ + +#ifndef SILABS_COMMON_H +#define SILABS_COMMON_H + +// App framework +#include "app/framework/include/af.h" +#include "app/framework/util/util.h" +#include "app/framework/util/time-util.h" +#include "app/framework/util/attribute-table.h" +#include "app/framework/util/attribute-storage.h" + +// the variables used to setup and send responses to cluster messages +extern EmberApsFrame emberAfResponseApsFrame; +extern uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; +extern uint16_t appResponseLength; +extern EmberNodeId emberAfResponseDestination; + +#endif //SILABS_COMMON_H diff --git a/examples/wifi-echo/server/esp32/main/config.h b/examples/wifi-echo/server/esp32/main/config.h new file mode 100644 index 00000000000000..3f00903d4d223d --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/config.h @@ -0,0 +1,297 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @brief This file is the main configuration settings for the Zigbee app. + * The zigbee app can become a Home Automation (HA) device, a Smart + * Energy (SE) device, or a Custom Zigbee device. + * + * This application can be configured using AppBuilder. AppBuilder + * generates a file containing defines that setup what pieces of the + * code is used (which clusters, security settings, zigbee device type, + * serial port, etc). These defines are added to a new file and included + * by setting ZA_GENERATED_HEADER to the new filename so these defines are + * sourced first. + * + * This file also contains default values for the defines so some can + * be set by the user but defaults are always available. + ******************************************************************************* + * # License + * Copyright 2018 Silicon Laboratories, Inc. www.silabs.com + ******************************************************************************* + * + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + ******************************************************************************/ + +#ifndef __EMBER_AF_CONFIG_H__ +#define __EMBER_AF_CONFIG_H__ + +// include generated configuration information from AppBuilder. +// ZA_GENERATED_HEADER is defined in the project file +#ifdef ZA_GENERATED_HEADER + #include ZA_GENERATED_HEADER +#endif + +#ifdef ATTRIBUTE_STORAGE_CONFIGURATION + #include ATTRIBUTE_STORAGE_CONFIGURATION +#endif +// ******************************************************************* +// pre-defined Devices +// +// use these to determine which type of device the current application is. +// do not use the EMBER_* versions from ember-types.h as these are in an +// enum and are not available at preprocessor time. These need to be set +// before the devices are loaded from ha-devices.h and se-devices.h +#define ZA_COORDINATOR 1 +#define ZA_ROUTER 2 +#define ZA_END_DEVICE 3 +#define ZA_SLEEPY_END_DEVICE 4 + +#define CBA_PROFILE_ID (0x0105) +#define HA_PROFILE_ID (0x0104) +#define SE_PROFILE_ID (0x0109) + +// A subtle distniction: +// EMBER_AF_MANUFACTURER_CODE is the MFG code set by AppBuilder +// for use in the App Framework (AF). If not set by AppBuilder we default +// it to 0x0000. The customer should be setting this value. +// EMBER_COMPANY_MANUFACTURER_CODE is the Ember Corporation's Manufacturer +// ID allocated by the Zigbee alliance. This shall not change. +#define EMBER_COMPANY_MANUFACTURER_CODE 0x1002 +#ifndef EMBER_AF_MANUFACTURER_CODE + #define EMBER_AF_MANUFACTURER_CODE 0x0000 +#endif + +// This file determines the security profile used, and from that various +// other security parameters. +#include "app/framework/security/security-config.h" + +// ******************************************************************* +// Application configuration of RAM for cluster usage +// +// This section defines constants that size the tables used by the cluster +// code. + +// This is the max hops that the network can support - used to determine +// the max source route overhead and broadcast radius +// if we havent defined MAX_HOPS then define based on profile ID +#ifndef ZA_MAX_HOPS + #ifdef EMBER_AF_HAS_SECURITY_PROFILE_SE + #define ZA_MAX_HOPS 6 + #else + #define ZA_MAX_HOPS 12 + #endif +#endif + +#ifndef EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH +#define EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH 0 +#endif + +// The maximum APS payload, not including any APS options. This value is also +// available from emberMaximumApsPayloadLength() or ezspMaximumPayloadLength(). +// See http://portal.ember.com/faq/payload for more information. +#ifdef EMBER_AF_HAS_SECURITY_PROFILE_NONE + #define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ + 100 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH +#else + #define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ + 82 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH +#endif + +// Max PHY size = 128 +// -1 byte for PHY length +// -2 bytes for MAC CRC +#define EMBER_AF_MAXIMUM_INTERPAN_LENGTH 125 + +// The additional overhead required for APS encryption (security = 5, MIC = 4). +#define EMBER_AF_APS_ENCRYPTION_OVERHEAD 9 + +// The additional overhead required for APS fragmentation. +#define EMBER_AF_APS_FRAGMENTATION_OVERHEAD 2 + +// The additional overhead required for network source routing (relay count = 1, +// relay index = 1). This does not include the size of the relay list itself. +#define EMBER_AF_NWK_SOURCE_ROUTE_OVERHEAD 2 + +// The additional overhead required per relay address for network source +// routing. This is in addition to the overhead defined above. +#define EMBER_AF_NWK_SOURCE_ROUTE_PER_RELAY_ADDRESS_OVERHEAD 2 + +// defines the largest size payload allowed to send and receive. This +// affects the payloads generated from the CLI and the payloads generated +// as responses. +// Maximum payload length. +// If fragmenation is enabled, and fragmentation length is bigger than default, then use that +#if defined(EMBER_AF_PLUGIN_FRAGMENTATION) \ + && (EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE > EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH) + #define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE + #define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE +#else + #define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH + #define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH +#endif + +// ******************************************************************* +// Application configuration of Flash +// +// This section gives the application options for turning on or off +// features that affect the amount of flash used. + +// ******************************************************************* +// Defines needed for enabling security +// + +// Unless we are not using security, our stack profile is 2 (ZigBee Pro). The +// stack will set up other configuration values based on profile. +#ifndef EMBER_AF_HAS_SECURITY_PROFILE_NONE + #define EMBER_STACK_PROFILE 2 +#else + #ifndef EMBER_STACK_PROFILE + #define EMBER_STACK_PROFILE 0 + #endif + #ifndef EMBER_SECURITY_LEVEL + #define EMBER_SECURITY_LEVEL 0 + #endif +#endif + +// ******************************************************************* +// Application Handlers +// +// By default, a number of stub handlers are automatically provided +// that have no effect. If the application would like to implement any +// of these handlers itself, it needs to define the appropriate macro + +#define EMBER_APPLICATION_HAS_REMOTE_BINDING_HANDLER +#define EMBER_APPLICATION_HAS_ENERGY_SCAN_RESULT_HANDLER +#define EMBER_APPLICATION_HAS_GET_ENDPOINT +#define EMBER_APPLICATION_HAS_TRUST_CENTER_JOIN_HANDLER +#define EMBER_APPLICATION_HAS_BUTTON_HANDLER +#define EMBER_APPLICATION_HAS_ZIGBEE_KEY_ESTABLISHMENT_HANDLER + +#define EZSP_APPLICATION_HAS_ENERGY_SCAN_RESULT_HANDLER +#define EZSP_APPLICATION_HAS_INCOMING_SENDER_EUI64_HANDLER +#define EZSP_APPLICATION_HAS_TRUST_CENTER_JOIN_HANDLER +#define EZSP_APPLICATION_HAS_BUTTON_HANDLER +#define EZSP_APPLICATION_HAS_ZIGBEE_KEY_ESTABLISHMENT_HANDLER + +#ifndef EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE + #define EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE EMBER_APS_UNICAST_MESSAGE_COUNT +#endif // EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE + +#define EMBER_APPLICATION_HAS_COMMAND_ACTION_HANDLER + +// ******************************************************************* +// Default values for required defines +// + +// define the serial port that the application uses to be 1 if this is not set +#ifndef HAL_CONFIG //HAL Config handles serial port allocation +#ifndef APP_SERIAL + #define APP_SERIAL 1 +#endif + #ifdef EMBER_TEST + #include "app/util/ezsp/uart-simulation-remap.h" + #endif +#endif + +// The address table plugin is enabled by default. If it gets disabled for some +// reason, we still need to define these #defines to some default value. +#ifndef EMBER_AF_PLUGIN_ADDRESS_TABLE + #define EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE 2 + #define EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE 2 +#endif + +// The total size of the address table is the size of the section used by the +// application plus the size of section used for the trust center address cache. +// The NCP allows each section to be sized independently, but the SOC requires +// a single configuration for the whole table. +#ifndef EMBER_ADDRESS_TABLE_SIZE + #define EMBER_ADDRESS_TABLE_SIZE \ + (EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE \ + + EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE) +#endif + +#ifndef EMBER_AF_DEFAULT_APS_OPTIONS +// BUGZID 12261: Concentrators use MTORRs for route discovery and should not +// enable route discovery in the APS options. + #ifdef EMBER_AF_PLUGIN_CONCENTRATOR + #define EMBER_AF_DEFAULT_APS_OPTIONS \ + (EMBER_APS_OPTION_RETRY \ + | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) + #else + #define EMBER_AF_DEFAULT_APS_OPTIONS \ + (EMBER_APS_OPTION_RETRY \ + | EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY \ + | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) + #endif +#endif + +// ******************************************************************* +// // Default values for required defines +// // + +#ifdef EMBER_AF_DEFAULT_RESPONSE_POLICY_NEVER + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS ZCL_DISABLE_DEFAULT_RESPONSE_MASK + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK +#elif defined(EMBER_AF_DEFAULT_RESPONSE_POLICY_CONDITIONAL) + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK +#else + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 + #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES 0 +#endif // EMBER_AF_DEFAULT_RESPONSE_POLICY_NEVER + +#ifdef EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS + #ifdef EMBER_AF_USE_STANDARD_NETWORK_INIT + #error "Custom options cannot be used with the standard network init" + #endif +#else + #ifdef EMBER_AF_HAS_SECURITY_PROFILE_Z3 // Z3 Compliant end devices must send a rejoin request on reboot + #define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_END_DEVICE_REJOIN_ON_REBOOT + #else // EMBER_AF_HAS_SECURITY_PROFILE_Z3 + #define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_NO_OPTIONS + #endif // EMBER_AF_HAS_SECURITY_PROFILE_Z3 + +// We always want to store our parent info in a token. This prevents doing an +// orphan scan upon reboot, which can suffer from the multiple-parent- +// responses issue + #define EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS (EMBER_NETWORK_INIT_PARENT_INFO_IN_TOKEN | Z3_NETWORK_INIT_BEHAVIOR) +#endif // EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS + +#endif // __EMBER_AF_CONFIG_H__ diff --git a/examples/wifi-echo/server/esp32/main/message.c b/examples/wifi-echo/server/esp32/main/message.c new file mode 100644 index 00000000000000..f21b1a9a7f2fbf --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/message.c @@ -0,0 +1,269 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief Code for manipulating the incoming and outgoing messages in a flat + * memory buffer. + ******************************************************************************* + ******************************************************************************/ + +#include "app/framework/include/af.h" +#include "app/framework/util/util.h" +#include "app/framework/util/config.h" + +//------------------------------------------------------------------------------ + +// these variables are for storing responses that are created by zcl-utils +// in functions called from emberIncomingMsgHandler. The response is sent +// from emberAfTick (meant to be called immediately after emberTick). +// There is only space for one response as each call to emberTick will +// only result in a single call to emberIncomingMsgHandler. If the device +// receives multiple ZCL messages, the stack will queue these and hand +// these to the application via emberIncomingMsgHandler one at a time. +EmberApsFrame emberAfResponseApsFrame; +EmberNodeId emberAfResponseDestination; +uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; +uint16_t appResponseLength; + +// Used for empty string +static uint16_t zeroLenByte = 0; +static uint8_t* zeroLenBytePtr = (uint8_t *)&zeroLenByte; + +//------------------------------------------------------------------------------ +// Utilities for adding bytes to the response buffer: appResponseData. These +// functions take care of incrementing appResponseLength. + +void emberAfClearResponseData(void) +{ + emberAfResponseType = ZCL_UTIL_RESP_NORMAL; + // To prevent accidentally sending to someone else, + // set the destination to ourselves. + emberAfResponseDestination = emberAfGetNodeId(); + MEMSET(appResponseData, 0, EMBER_AF_RESPONSE_BUFFER_LEN); + appResponseLength = 0; + MEMSET(&emberAfResponseApsFrame, 0, sizeof(EmberApsFrame)); +} + +uint8_t * emberAfPutInt8uInResp(uint8_t value) +{ + //emberAfDebugPrint("try %x max %x\r\n", appResponseLength, EMBER_AF_RESPONSE_BUFFER_LEN); + if (appResponseLength < EMBER_AF_RESPONSE_BUFFER_LEN) { + //emberAfDebugPrint("put %x at spot %x\r\n", value, appResponseLength); + appResponseData[appResponseLength] = value; + appResponseLength++; + return &appResponseData[appResponseLength - 1]; + } + + return NULL; +} + +uint16_t * emberAfPutInt16uInResp(uint16_t value) +{ + uint8_t * low = emberAfPutInt8uInResp(LOW_BYTE(value)); + uint8_t * high = emberAfPutInt8uInResp(HIGH_BYTE(value)); + + if (low && high) { + return (uint16_t *) low; + } else { + return NULL; + } +} + +uint32_t * emberAfPutInt32uInResp(uint32_t value) +{ + uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); + uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); + uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); + uint8_t * d = emberAfPutInt8uInResp(BYTE_3(value)); + + if (a && b && c && d) { + return (uint32_t *)a; + } else { + return NULL; + } +} + +uint32_t * emberAfPutInt24uInResp(uint32_t value) +{ + uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); + uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); + uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); + + if (a && b && c) { + return (uint32_t *) a; + } else { + return NULL; + } +} + +uint8_t * emberAfPutBlockInResp(const uint8_t* data, uint16_t length) +{ + if ((appResponseLength + length) < EMBER_AF_RESPONSE_BUFFER_LEN) { + MEMMOVE(appResponseData + appResponseLength, data, length); + appResponseLength += length; + return &appResponseData[appResponseLength - length]; + } else { + return NULL; + } +} + +uint8_t * emberAfPutStringInResp(const uint8_t *buffer) +{ + uint8_t length = emberAfStringLength(buffer); + return emberAfPutBlockInResp(buffer, length + 1); +} + +uint8_t * emberAfPutDateInResp(EmberAfDate *value) +{ + uint8_t * a = emberAfPutInt8uInResp(value->year); + uint8_t * b = emberAfPutInt8uInResp(value->month); + uint8_t * c = emberAfPutInt8uInResp(value->dayOfMonth); + uint8_t * d = emberAfPutInt8uInResp(value->dayOfWeek); + + if (a && b && c && d) { + return a; + } else { + return NULL; + } +} + +// ------------------------------------ +// Utilities for reading from RAM buffers (reading from incoming message +// buffer) +// ------------------------------------ + +// retrieves an uint32_t which contains between 1 and 4 bytes of relevent data +// depending on number of bytes requested. +uint32_t emberAfGetInt(const uint8_t* message, + uint16_t currentIndex, + uint16_t msgLen, + uint8_t bytes) +{ + uint32_t result = 0; + uint8_t i = bytes; + if ((currentIndex + bytes) > msgLen) { + emberAfDebugPrintln("GetInt, %x bytes short", bytes); + emberAfDebugFlush(); + return 0; + } + while (i > 0) { + result = (result << 8) + message[(currentIndex + i) - 1]; + i--; + } + return result; +} + +uint32_t emberAfGetInt32u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +{ + return emberAfGetInt(message, currentIndex, msgLen, 4); +} + +uint32_t emberAfGetInt24u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +{ + return emberAfGetInt(message, currentIndex, msgLen, 3); +} + +uint16_t emberAfGetInt16u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +{ + return (uint16_t)emberAfGetInt(message, currentIndex, msgLen, 2); +} + +uint8_t* emberAfGetString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +{ + // Strings must contain at least one byte for the length. + if (msgLen <= currentIndex) { + emberAfDebugPrintln("GetString: %p", "buffer too short"); + return zeroLenBytePtr; + } + + // Starting from the current index, there must be enough bytes in the message + // for the string and the length byte. + if (msgLen < currentIndex + emberAfStringLength(&message[currentIndex]) + 1) { + emberAfDebugPrintln("GetString: %p", "len byte wrong"); + return zeroLenBytePtr; + } + + return &message[currentIndex]; +} + +uint8_t* emberAfGetLongString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +{ + // Long strings must contain at least two bytes for the length. + if (msgLen <= currentIndex + 1) { + emberAfDebugPrintln("GetLongString: %p", "buffer too short"); + return zeroLenBytePtr; + } + + // Starting from the current index, there must be enough bytes in the message + // for the string and the length bytes. + if (msgLen + < currentIndex + emberAfLongStringLength(&message[currentIndex]) + 2) { + emberAfDebugPrintln("GetLongString: %p", "len bytes wrong"); + return zeroLenBytePtr; + } + + return &message[currentIndex]; +} + +uint8_t emberAfStringLength(const uint8_t *buffer) +{ + // The first byte specifies the length of the string. A length of 0xFF means + // the string is invalid and there is no character data. + return (buffer[0] == 0xFF ? 0 : buffer[0]); +} + +uint16_t emberAfLongStringLength(const uint8_t *buffer) +{ + // The first two bytes specify the length of the long string. A length of + // 0xFFFF means the string is invalid and there is no character data. + uint16_t length = emberAfGetInt16u(buffer, 0, 2); + return (length == 0xFFFF ? 0 : length); +} + +uint8_t emberAfGetDate(uint8_t* message, + uint16_t currentIndex, + uint16_t msgLen, + EmberAfDate *destination) +{ + if ((currentIndex + 4) > msgLen) { + emberAfDebugPrintln("GetDate, %x bytes short", 4); + emberAfDebugFlush(); + return 0; + } + destination->year = message[(currentIndex + 0)]; + destination->month = message[(currentIndex + 1)]; + destination->dayOfMonth = message[(currentIndex + 2)]; + destination->dayOfWeek = message[(currentIndex + 3)]; + return 4; +} diff --git a/examples/wifi-echo/server/esp32/main/on-off.c b/examples/wifi-echo/server/esp32/main/on-off.c new file mode 100644 index 00000000000000..a21a046f9cf782 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/on-off.c @@ -0,0 +1,301 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief Routines for the On-Off plugin, which implements the On-Off server + * cluster. + ******************************************************************************* + ******************************************************************************/ + +#include "af.h" + +#ifdef EMBER_AF_PLUGIN_REPORTING + #include "app/framework/plugin/reporting/reporting.h" +#endif + +#ifdef EMBER_AF_PLUGIN_SCENES + #include "../scenes/scenes.h" +#endif //EMBER_AF_PLUGIN_SCENES + +#ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER + #include "../zll-on-off-server/zll-on-off-server.h" +#endif + +#ifdef EMBER_AF_PLUGIN_ZLL_LEVEL_CONTROL_SERVER + #include "../zll-level-control-server/zll-level-control-server.h" +#endif + +#ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE +static bool areStartUpOnOffServerAttributesTokenized(uint8_t endpoint); +#endif + +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, + uint8_t command, + bool initiatedByLevelChange) +{ + EmberAfStatus status; + bool currentValue, newValue; + + emberAfOnOffClusterPrintln("On/Off set value: %x %x", endpoint, command); + + // read current on/off value + status = emberAfReadAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)¤tValue, + sizeof(currentValue), + NULL); // data type + if (status != EMBER_ZCL_STATUS_SUCCESS) { + emberAfOnOffClusterPrintln("ERR: reading on/off %x", status); + return status; + } + + // if the value is already what we want to set it to then do nothing + if ((!currentValue && command == ZCL_OFF_COMMAND_ID) + || (currentValue && command == ZCL_ON_COMMAND_ID)) { + emberAfOnOffClusterPrintln("On/off already set to new value"); + return EMBER_ZCL_STATUS_SUCCESS; + } + + // we either got a toggle, or an on when off, or an off when on, + // so we need to swap the value + newValue = !currentValue; + emberAfOnOffClusterPrintln("Toggle on/off from %x to %x", currentValue, newValue); + + // the sequence of updating on/off attribute and kick off level change effect should + // be depend on whether we are turning on or off. If we are turning on the light, we + // should update the on/off attribute before kicking off level change, if we are + // turning off the light, we should do the opposite, that is kick off level change + // before updating the on/off attribute. + if (newValue) { + // write the new on/off value + status = emberAfWriteAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)&newValue, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); + return status; + } + + // If initiatedByLevelChange is false, then we assume that the level change + // ZCL stuff has not happened and we do it here + if (!initiatedByLevelChange + && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) { + emberAfOnOffClusterLevelControlEffectCallback(endpoint, + newValue); + } + } else { + // If initiatedByLevelChange is false, then we assume that the level change + // ZCL stuff has not happened and we do it here + if (!initiatedByLevelChange + && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) { + emberAfOnOffClusterLevelControlEffectCallback(endpoint, + newValue); + } + + // write the new on/off value + status = emberAfWriteAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)&newValue, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); + return status; + } + } + +#ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER + if (initiatedByLevelChange) { + emberAfPluginZllOnOffServerLevelControlZllExtensions(endpoint); + } +#endif + + // the scene has been changed (the value of on/off has changed) so + // the current scene as descibed in the attribute table is invalid, + // so mark it as invalid (just writes the valid/invalid attribute) + if (emberAfContainsServer(endpoint, ZCL_SCENES_CLUSTER_ID)) { + emberAfScenesClusterMakeInvalidCallback(endpoint); + } + + // The returned status is based solely on the On/Off cluster. Errors in the + // Level Control and/or Scenes cluster are ignored. + return EMBER_ZCL_STATUS_SUCCESS; +} + +bool emberAfOnOffClusterOffCallback(void) +{ + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), + ZCL_OFF_COMMAND_ID, + false); +#ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER + if (status == EMBER_ZCL_STATUS_SUCCESS) { + emberAfPluginZllOnOffServerOffZllExtensions(emberAfCurrentCommand()); + } +#endif + emberAfSendImmediateDefaultResponse(status); + return true; +} + +bool emberAfOnOffClusterOnCallback(void) +{ + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), + ZCL_ON_COMMAND_ID, + false); +#ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER + if (status == EMBER_ZCL_STATUS_SUCCESS) { + emberAfPluginZllOnOffServerOnZllExtensions(emberAfCurrentCommand()); + } +#endif + emberAfSendImmediateDefaultResponse(status); + return true; +} + +bool emberAfOnOffClusterToggleCallback(void) +{ + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), + ZCL_TOGGLE_COMMAND_ID, + false); +#ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER + if (status == EMBER_ZCL_STATUS_SUCCESS) { + emberAfPluginZllOnOffServerToggleZllExtensions(emberAfCurrentCommand()); + } +#endif + emberAfSendImmediateDefaultResponse(status); + return true; +} + +void emberAfOnOffClusterServerInitCallback(uint8_t endpoint) +{ +#ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE + // StartUp behavior relies on OnOff and StartUpOnOff attributes being tokenized. + if (areStartUpOnOffServerAttributesTokenized(endpoint)) { + // Read the StartUpOnOff attribute and set the OnOff attribute as per + // following from zcl 7 14-0127-20i-zcl-ch-3-general.doc. + // 3.8.2.2.5 StartUpOnOff Attribute + // The StartUpOnOff attribute SHALL define the desired startup behavior of a + // lamp device when it is supplied with power and this state SHALL be + // reflected in the OnOff attribute. The values of the StartUpOnOff + // attribute are listed below. + // Table 3 46. Values of the StartUpOnOff Attribute + // Value Action on power up + // 0x00 Set the OnOff attribute to 0 (off). + // 0x01 Set the OnOff attribute to 1 (on). + // 0x02 If the previous value of the OnOff attribute is equal to 0, + // set the OnOff attribute to 1.If the previous value of the OnOff + // attribute is equal to 1, set the OnOff attribute to 0 (toggle). + // 0x03-0xfe These values are reserved. No action. + // 0xff Set the OnOff attribute to its previous value. + + // Initialize startUpOnOff to No action value 0xFE + uint8_t startUpOnOff = 0xFE; + EmberAfStatus status = emberAfReadAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)&startUpOnOff, + sizeof(startUpOnOff), + NULL); + if (status == EMBER_ZCL_STATUS_SUCCESS) { + // Initialise updated value to 0 + bool updatedOnOff = 0; + status = emberAfReadAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)&updatedOnOff, + sizeof(updatedOnOff), + NULL); + if (status == EMBER_ZCL_STATUS_SUCCESS) { + switch (startUpOnOff) { + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF: + updatedOnOff = 0; // Off + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON: + updatedOnOff = 1; //On + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE: + updatedOnOff = !updatedOnOff; + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS: + default: + // All other values 0x03- 0xFE are reserved - no action. + // When value is 0xFF - update with last value - that is as good as + // no action. + break; + } + status = emberAfWriteAttribute(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + (uint8_t *)&updatedOnOff, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); + } + } + } +#endif + emberAfPluginOnOffClusterServerPostInitCallback(endpoint); +} + +#ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE +static bool areStartUpOnOffServerAttributesTokenized(uint8_t endpoint) +{ + EmberAfAttributeMetadata *metadata; + + metadata = emberAfLocateAttributeMetadata(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + EMBER_AF_NULL_MANUFACTURER_CODE); + if (!emberAfAttributeIsTokenized(metadata)) { + return false; + } + + metadata = emberAfLocateAttributeMetadata(endpoint, + ZCL_ON_OFF_CLUSTER_ID, + ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, + EMBER_AF_NULL_MANUFACTURER_CODE); + if (!emberAfAttributeIsTokenized(metadata)) { + return false; + } + + return true; +} +#endif diff --git a/examples/wifi-echo/server/esp32/main/process-cluster-message.c b/examples/wifi-echo/server/esp32/main/process-cluster-message.c new file mode 100644 index 00000000000000..566f34ed0ff288 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/process-cluster-message.c @@ -0,0 +1,113 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains a function that processes cluster-specific + * ZCL message. + ******************************************************************************* + ******************************************************************************/ + +// this file contains all the common includes for clusters in the zcl-util +#include "common.h" + +// for pulling in defines dealing with EITHER server or client +#include "af-main.h" + +// the EM260 host needs to include the config file +#ifdef EZSP_HOST + #include "config.h" +#endif + +//------------------------------------------------------------------------------ +// Forward Declarations + +EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand *cmd); + +//------------------------------------------------------------------------------ + +bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand *cmd) +{ + EmberAfStatus status; + + // if we are disabled then we can only respond to read or write commands + // or identify cluster (see device enabled attr of basic cluster) + if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) + && cmd->apsFrame->clusterId != ZCL_IDENTIFY_CLUSTER_ID) { + emberAfCorePrintln("%pd, dropping ep 0x%x clus 0x%2x cmd 0x%x", + "disable", + cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->clusterId, + cmd->commandId); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); + return true; + } + +#ifdef ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_CLIENT + if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID + && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT + && emberAfKeyEstablishmentClusterClientCommandReceivedCallback(cmd)) { + return true; + } +#endif +#ifdef ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_SERVER + if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID + && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + && emberAfKeyEstablishmentClusterServerCommandReceivedCallback(cmd)) { + return true; + } +#endif + +#ifdef ZCL_USING_OTA_BOOTLOAD_CLUSTER_CLIENT + if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID + && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT + && emberAfOtaClientIncomingMessageRawCallback(cmd)) { + return true; + } +#endif +#ifdef ZCL_USING_OTA_BOOTLOAD_CLUSTER_SERVER + if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID + && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + && emberAfOtaServerIncomingMessageRawCallback(cmd)) { + return true; + } +#endif + + // Pass the command to the generated command parser for processing + status = emberAfClusterSpecificCommandParse(cmd); + if (status != EMBER_ZCL_STATUS_SUCCESS) { + emberAfSendDefaultResponse(cmd, status); + } + + return true; +} diff --git a/examples/wifi-echo/server/esp32/main/process-global-message.c b/examples/wifi-echo/server/esp32/main/process-global-message.c new file mode 100644 index 00000000000000..cb790b1ef264f2 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/process-global-message.c @@ -0,0 +1,755 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains function that processes global ZCL message. + ******************************************************************************* + ******************************************************************************/ + +#include "../include/af.h" +#include "common.h" +#include "../plugin/ias-zone-client/ias-zone-client.h" +#include "../plugin/key-establishment/key-establishment.h" +#include "../plugin/smart-energy-registration/smart-energy-registration.h" +#include "../plugin/trust-center-keepalive/trust-center-keepalive.h" +#include "../plugin/test-harness/test-harness.h" +#ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS + #include "../plugin/wwah-server-silabs/wwah-server-silabs.h" +#endif +#include "../plugin/simple-metering-server/simple-metering-server.h" +#include "znet-bookkeeping.h" // emAfRetrieveAttributeAndCraftResponse + +#ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ + #include "app/framework/plugin/comms-hub-function-sub-ghz/comms-hub-function-sub-ghz.h" +#endif + +// flag to keep track of the fact that we just sent a read attr for time and +// we should set our time to the result of the read attr response. +bool emAfSyncingTime = false; + +#ifdef EMBER_AF_GBCS_COMPATIBLE +// Some GBCS use cases (e.g. GCS15e, GCS21f) require that ReadAttributesResponse +// should be send back with Disable Default Response flag set. The only pattern +// is that the decision is based on the cluster and attribute IDs requested. +// To reduce the possibility of false positives, we disable default response +// only for responses containing at least the specified minimum of attributes. +#define MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE 3 +#endif + +#define DISC_ATTR_RSP_MAX_ATTRIBUTES \ + (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ + - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ + - 1) /* discovery is complete boolean */ \ + / 3) /* size of one discover attributes response entry */ \ + % UINT8_MAX) /* make count fit in an 8 bit integer */ +#define DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES \ + (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ + - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ + - 1) /* discovery is complete boolean */ \ + / 4) /* size of one discover attributes extended response entry */ \ + % UINT8_MAX) /* make count fit in an 8 bit integer */ + +#if defined(EMBER_AF_SUPPORT_COMMAND_DISCOVERY) +static void printDiscoverCommandsResponse(bool generated, + uint16_t clusterId, + bool discoveryComplete, + uint8_t* buffer, + uint16_t length) +{ + uint16_t i; + emberAfServiceDiscoveryPrint("Discover Commands response (complete: %c), %p IDs: ", + (discoveryComplete + ? 'y' + : 'n'), + (generated + ? "Generated" + : "Received")); + for (i = 0; i < length; i++) { + emberAfServiceDiscoveryPrint("0x%X ", buffer[i]); + } + emberAfServiceDiscoveryPrintln(""); +} +#endif + +bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd) +{ + uint16_t attrId; + uint8_t frameControl; + // This is a little clumsy but easier to read and port + // from earlier implementation. + EmberAfClusterId clusterId = cmd->apsFrame->clusterId; + uint8_t zclCmd = cmd->commandId; + uint8_t *message = cmd->buffer; + uint16_t msgLen = cmd->bufLen; + uint16_t msgIndex = cmd->payloadStartIndex; + uint8_t clientServerMask = (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + ? CLUSTER_MASK_SERVER + : CLUSTER_MASK_CLIENT); + + // If we are disabled then we can only respond to read or write commands + // or identify cluster (see device enabled attr of basic cluster) + if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) + && zclCmd != ZCL_READ_ATTRIBUTES_COMMAND_ID + && zclCmd != ZCL_WRITE_ATTRIBUTES_COMMAND_ID + && zclCmd != ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID + && zclCmd != ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID + && clusterId != ZCL_IDENTIFY_CLUSTER_ID) { + emberAfCorePrintln("disabled"); + emberAfDebugPrintln("%pd, dropping global cmd:%x", "disable", zclCmd); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); + return true; + } + + // If a manufacturer-specific command arrives using our special internal "not + // manufacturer specific" code, we need to reject it outright without letting + // it pass through to the rest of the code. The internal read and write APIs + // would interpret it as a standard attribute or cluster and return incorrect + // results. + if (cmd->mfgSpecific && cmd->mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) { + goto kickout; + } + + // Clear out the response buffer by setting its length to zero + appResponseLength = 0; + + // Make the ZCL header for the response + // note: cmd byte is set below + frameControl = (ZCL_GLOBAL_COMMAND + | (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT + | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES + : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER + | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES)); + if (cmd->mfgSpecific) { + frameControl |= ZCL_MANUFACTURER_SPECIFIC_MASK; + } + emberAfPutInt8uInResp(frameControl); + if (cmd->mfgSpecific) { + emberAfPutInt16uInResp(cmd->mfgCode); + } + emberAfPutInt8uInResp(cmd->seqNum); + + switch (zclCmd) { + // The format of the read attributes cmd is: + // ([attr ID:2]) * N + // The format of the read attributes response is: + // ([attr ID:2] [status:1] [data type:0/1] [data:0/N]) * N + case ZCL_READ_ATTRIBUTES_COMMAND_ID: + { + emberAfAttributesPrintln("%p: clus %2x", "READ_ATTR", clusterId); + // Set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp(ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID); + + // This message contains N 2-byte attr IDs after the 3 byte ZCL header, + // for each one we need to look it up and make a response + while (msgIndex + 2 <= msgLen) { + // Get the attribute ID and store it in the response buffer + // least significant byte is first OTA + attrId = emberAfGetInt16u(message, msgIndex, msgLen); + +#ifdef EMBER_AF_GBCS_COMPATIBLE + // GBCS explicitly lists some commands that need to be sent with "disable + // default response" flag set, including some ReadAttributes responses. + // We make it conditional on GBCS so it does not affect standard SE apps. + { + static const struct { + EmberAfClusterId clusterId; + uint16_t attrId; + } noDefaultResponseSet[] = { + { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_STANDING_CHARGE_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_MULTIPLIER_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_DIVISOR_ATTRIBUTE_ID }, + }; + uint8_t i; + uint8_t foundMatchingAttrIdsCount = 0; + + for (i = 0; i < sizeof noDefaultResponseSet / sizeof noDefaultResponseSet[0]; ++i) { + if (noDefaultResponseSet[i].clusterId == clusterId + && noDefaultResponseSet[i].attrId == attrId) { + if (++foundMatchingAttrIdsCount >= MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE) { + emberAfSetDisableDefaultResponse(EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT); + break; + } + } + } + } + + #ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ + // This plugin sets channel change notification flags and needs to know + // when those flags have been read. + if (clientServerMask == CLUSTER_MASK_SERVER) { + emAfCommsHubFunctionSubGhzReadAttributeNotification(cmd->source, + clusterId, + attrId); + } + #endif +#endif + + // This function reads the attribute and creates the correct response + // in the response buffer + if (!emAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, + clusterId, + attrId, + clientServerMask, + cmd->mfgCode, + (EMBER_AF_RESPONSE_BUFFER_LEN + - appResponseLength))) { + emberAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, + clusterId, + attrId, + clientServerMask, + cmd->mfgCode, + (EMBER_AF_RESPONSE_BUFFER_LEN + - appResponseLength)); + } + + // Go to next attrID + msgIndex += 2; + } + } + + emberAfSendResponse(); + return true; + + // Write undivided means all attributes must be written in order to write + // any of them. So first do a check. If the check fails, send back a fail + // response. If it works, fall through to the normal write attr code. + // write attr responses are the same for undivided and normal writes. + case ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID: + { + uint8_t numFailures = 0; + uint8_t dataType; + uint16_t dataSize; + EmberAfStatus status; + + emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); + + // Go through the message until there are no more attrID/type/data + while (msgIndex < msgLen - 3) { + attrId = emberAfGetInt16u(message, msgIndex, msgLen); + dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); + + dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); + + // Check to see if there are dataSize bytes left in the message if it is a string + if (emberAfIsThisDataTypeAStringType(dataType) + && (dataSize < msgLen - (msgIndex + 3))) { + // This command is malformed + status = EMBER_ZCL_STATUS_MALFORMED_COMMAND; + } else { + status = emberAfVerifyAttributeWrite(cmd->apsFrame->destinationEndpoint, + clusterId, + attrId, + clientServerMask, + cmd->mfgCode, + &(message[msgIndex + 3]), + dataType); + } + + if (status != EMBER_ZCL_STATUS_SUCCESS) { + numFailures++; + // Write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + + emberAfAttributesPrintln("WRITE: clus %2x attr %2x ", clusterId, attrId); + emberAfAttributesPrintln("FAIL %x", status); + emberAfCoreFlush(); + if (status == EMBER_ZCL_STATUS_MALFORMED_COMMAND) { + // this attribute is malformed, terminate attribute processing. + break; + } + } + + // Increment past the attribute id (two bytes), the type (one byte), and + // the data (N bytes, including the length byte for strings). + msgIndex += 3 + dataSize; + } + // If there are any failures, send the response and exit + if (numFailures > 0) { + emberAfSendResponse(); + return true; + } + } + // Reset message back to start + msgIndex = cmd->payloadStartIndex; + appResponseLength = (cmd->mfgSpecific ? 4 : 2); + // DO NOT BREAK from this case + + // the format of the write attributes cmd is: + // ([attr ID:2] [data type:1] [data:N]) * N + // the format of the write attributes response is: + // ([status 1] [attr ID 2]) * n + // ONLY errors are reported unless all are successful then a single success + // is sent. write attr no response is handled by just executing the same + // code but not setting the flag that sends the response at the end. + case ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID: + case ZCL_WRITE_ATTRIBUTES_COMMAND_ID: + { + uint8_t numFailures = 0; + uint8_t numSuccess = 0; + uint8_t dataType; + uint16_t dataSize; +#if (BIGENDIAN_CPU) + uint8_t writeData[ATTRIBUTE_LARGEST]; +#endif //(BIGENDIAN_CPU) + EmberAfStatus status; + + // set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); + + // go through the message until there are no more attrID/type/data + while (msgLen > msgIndex + 3) { + attrId = emberAfGetInt16u(message, msgIndex, msgLen); + dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); + + dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); + + // the data is sent little endian over-the-air, it needs to be + // inserted into the table big endian for the EM250 and little + // endian for the EZSP hosts. This means for the EM250 the data + // needs to be reversed before sending to writeAttributes +#if (BIGENDIAN_CPU) + if (dataSize <= msgLen - (msgIndex + 3) && dataSize <= ATTRIBUTE_LARGEST) { + // strings go over the air as length byte and then in human + // readable format. These should not be flipped. + if (emberAfIsThisDataTypeAStringType(dataType)) { + MEMMOVE(writeData, message + msgIndex + 3, dataSize); + } else { + // the data is sent little endian over-the-air, it needs to be + // inserted into the table big endian + uint16_t i; + for (i = 0; i < dataSize; i++) { + writeData[i] = message[msgIndex + 3 + dataSize - i - 1]; + } + } +#else //(BIGENDIAN_CPU) + if (dataSize <= msgLen - (msgIndex + 3)) { +#endif //(BIGENDIAN_CPU) + + status = emberAfWriteAttributeExternal(cmd->apsFrame->destinationEndpoint, + clusterId, + attrId, + clientServerMask, + cmd->mfgCode, + #if (BIGENDIAN_CPU) + writeData, + #else //(BIGENDIAN_CPU) + &(message[msgIndex + 3]), + #endif //(BIGENDIAN_CPU) + dataType); + emberAfAttributesPrint("WRITE: clus %2x attr %2x ", + clusterId, + attrId); + if (status == EMBER_ZCL_STATUS_SUCCESS) { + numSuccess++; + emberAfAttributesPrintln("OK"); + } else { + numFailures++; + // write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + emberAfAttributesPrintln("FAIL %x", status); + } + emberAfCoreFlush(); + + // Increment past the attribute id (two bytes), the type (one byte), and + // the data (N bytes, including the length byte for strings). + msgIndex += 3 + dataSize; + } else { + numFailures++; + status = EMBER_ZCL_STATUS_INVALID_VALUE; + // write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + emberAfAttributesPrintln("FAIL %x", status); + // size exceeds buffer, terminate loop + break; + } + } + + // always send a response unless the cmd requested no response + if (zclCmd == ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID) { + return true; + } + + if (numFailures == 0) { + // if no failures and no success this means the packet was too short + // print an error message but still return true as we consumed the + // message + if (numSuccess == 0) { + emberAfAttributesPrintln("WRITE: too short"); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_MALFORMED_COMMAND); + return true; + } + // if no failures and at least one success, write a success status + // that means everything worked + else { + emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); + } + } + emberAfSendResponse(); + return true; + } + + // the format of discover is: [start attr ID:2] [max attr IDs:1] + // the format of the response is: [done:1] ([attrID:2] [type:1]) * N + case ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID: + case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID: + { + EmberAfAttributeId startingAttributeId; + uint8_t numberAttributes; + uint8_t *complete; + + emberAfAttributesPrintln("%p%p: clus %2x", "DISC_ATTR", + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID ? "_EXT" : ""), + clusterId); + + // set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp( + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID + ? ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID + : ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID)); + + // get the attrId to start on and the max count + startingAttributeId = emberAfGetInt16u(message, msgIndex, msgLen); + numberAttributes = emberAfGetInt8u(message, msgIndex + 2, msgLen); + + // BUGZID: EMAPPFWKV2-828, EMAPPFWKV2-1401 + if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID + && numberAttributes > DISC_ATTR_RSP_MAX_ATTRIBUTES) { + numberAttributes = DISC_ATTR_RSP_MAX_ATTRIBUTES; + } else if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID + && numberAttributes > DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES) { + numberAttributes = DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES; + } else { + // MISRA requires ..else if.. to have terminating else. + } + + // The response has a one-byte field indicating whether discovery is + // complete. We can't populate that field until we've finished going + // through all the attributes, so save a placeholder, write a temporary + // value for now (so that the offset moves forward), and write the real + // value when we're done. + complete = &(appResponseData[appResponseLength]); + emberAfPutInt8uInResp(false); + *complete = emberAfReadSequentialAttributesAddToResponse( + cmd->apsFrame->destinationEndpoint, + clusterId, + startingAttributeId, + clientServerMask, + cmd->mfgCode, + numberAttributes, + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID)); + emberAfSendResponse(); + return true; + } + + case ZCL_CONFIGURE_REPORTING_COMMAND_ID: + if (emberAfConfigureReportingCommandCallback(cmd)) { + return true; + } + break; + + case ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID: + if (emberAfReadReportingConfigurationCommandCallback(cmd)) { + return true; + } + break; + + // ([attribute id:2] [status:1] [type:0/1] [value:0/V])+ + case ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID: + // The "timesync" command in the CLI sends a Read Attributes command for the + // Time attribute on another device and then sets a flag. If that flag is + // set and a Read Attributes Response command for the time comes in, we set + // the time to the value in the message. + if (clusterId == ZCL_TIME_CLUSTER_ID) { + if (emAfSyncingTime + && !cmd->mfgSpecific + && msgLen - msgIndex == 8 // attr:2 status:1 type:1 data:4 + && (emberAfGetInt16u(message, msgIndex, msgLen) + == ZCL_TIME_ATTRIBUTE_ID) + && (emberAfGetInt8u(message, msgIndex + 2, msgLen) + == EMBER_ZCL_STATUS_SUCCESS) + && (emberAfGetInt8u(message, msgIndex + 3, msgLen) + == ZCL_UTC_TIME_ATTRIBUTE_TYPE)) { + emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen)); + emberAfDebugPrintln("time sync ok, time: %4x", emberAfGetCurrentTime()); + emAfSyncingTime = false; + } +#ifdef EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED + emAfPluginSmartEnergyRegistrationReadAttributesResponseCallback(message + msgIndex, + msgLen - msgIndex); +#endif //EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED +#ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS + emAfPluginSlWwahReadAttributesResponseCallback(clusterId, message, msgLen); +#endif + } + +#ifdef EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE + if (clusterId == ZCL_KEEPALIVE_CLUSTER_ID + && !cmd->mfgSpecific) { + emAfPluginTrustCenterKeepaliveReadAttributesResponseCallback(message + msgIndex, + msgLen - msgIndex); + } +#endif //EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE + +#if defined(EMBER_AF_PLUGIN_KEY_ESTABLISHMENT) + if (clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID + && !cmd->mfgSpecific + && msgLen - msgIndex == 6 //attr:2 status:1 type:1 data:2 + && (emberAfGetInt16u(message, msgIndex, msgLen) + == ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID) + && (emberAfGetInt8u(message, msgIndex + 2, msgLen) + == EMBER_ZCL_STATUS_SUCCESS) + && ((emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_ENUM16_ATTRIBUTE_TYPE) + || (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_BITMAP16_ATTRIBUTE_TYPE))) { + uint16_t suite = emberAfGetInt16u(message, msgIndex + 4, msgLen); + emberAfPluginKeyEstablishmentReadAttributesCallback(suite); + } +#endif + +#if defined(EMBER_AF_PLUGIN_TEST_HARNESS) + emberAfPluginTestHarnessReadAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex); +#endif + +#if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT) + emberAfPluginIasZoneClientReadAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex); +#endif + +#if defined(EMBER_AF_PLUGIN_SIMPLE_METERING_SERVER) + emberAfPluginSimpleMeteringClusterReadAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex); +#endif + + if (!emAfReadAttributesResponse(clusterId, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + + // ([status:1] [attribute id:2])+ + case ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID: + + #if defined(EMBER_AF_PLUGIN_TEST_HARNESS) + emberAfPluginTestHarnessWriteAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex); + #endif + + #if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT) + emberAfPluginIasZoneClientWriteAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex); + #endif + + if (!emberAfWriteAttributesResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + + // ([status:1] [direction:1] [attribute id:2])+ + case ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID: + if (!emberAfConfigureReportingResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + + // ([status:1] [direction:1] [attribute id:2] [type:0/1] ... + // ... [min interval:0/2] [max interval:0/2] [reportable change:0/V] ... + // ... [timeout:0/2])+ + case ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID: + if (!emberAfReadReportingConfigurationResponseCallback(clusterId, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + + // ([attribute id:2] [type:1] [data:V])+ + case ZCL_REPORT_ATTRIBUTES_COMMAND_ID: + if (!emAfReportAttributes(clusterId, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + + // [command id:1] [status:1] + case ZCL_DEFAULT_RESPONSE_COMMAND_ID: + { + EmberAfStatus status; + uint8_t commandId; + commandId = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + status = (EmberAfStatus)emberAfGetInt8u(message, msgIndex, msgLen); + + emberAfClusterDefaultResponseWithMfgCodeCallback(cmd->apsFrame->destinationEndpoint, + clusterId, + commandId, + status, + clientServerMask, + cmd->mfgCode); + emberAfDefaultResponseCallback(clusterId, commandId, status); + return true; + } + + // [discovery complete:1] ([attribute id:2] [type:1])* + case ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID: + case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID: + { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if (!emberAfDiscoverAttributesResponseCallback(clusterId, + discoveryComplete, + message + msgIndex, + msgLen - msgIndex, + (zclCmd + == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID))) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + } + +#ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY + // Command discovery takes a bit of flash because we need to add structs + // for commands into the generated hader. Hence it's all configurable. + case ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID: + case ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID: + { + uint8_t startCommandIdentifier = emberAfGetInt8u(message, msgIndex, msgLen); + uint8_t maximumCommandIdentifiers = emberAfGetInt8u(message, msgIndex + 1, msgLen); + uint16_t savedIndex; + bool flag; + + // Ok. This is the command that matters. + if ( zclCmd == ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID ) { + emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID); + flag = false; + } else { + emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID); + flag = true; + } + savedIndex = appResponseLength; + flag = emberAfExtractCommandIds(flag, + cmd, + clusterId, + appResponseData + appResponseLength + 1, + EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength - 1, + &appResponseLength, + startCommandIdentifier, + maximumCommandIdentifiers); + appResponseData[savedIndex] = (flag ? 1 : 0); + appResponseLength++; + emberAfSendResponse(); + return true; + } + case ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID: + { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if ( msgIndex <= msgLen ) { + printDiscoverCommandsResponse(false, // is ZCL command generated? + clusterId, + discoveryComplete, + message + msgIndex, + msgLen - msgIndex); + if (!emberAfDiscoverCommandsReceivedResponseCallback(clusterId, + cmd->mfgCode, + discoveryComplete, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + } else { + return false; + } + } + case ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID: + { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if ( msgIndex <= msgLen ) { + printDiscoverCommandsResponse(true, // is ZCL command generated? + clusterId, + discoveryComplete, + message + msgIndex, + msgLen - msgIndex); + if (!emberAfDiscoverCommandsGeneratedResponseCallback(clusterId, + cmd->mfgCode, + discoveryComplete, + message + msgIndex, + msgLen - msgIndex)) { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + } else { + return false; + } + } + +#endif + default: + // MISRA requires default case. + break; + } + + kickout: + emberAfSendDefaultResponse(cmd, + (cmd->mfgSpecific + ? EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND + : EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND)); + return true; +} diff --git a/examples/wifi-echo/server/esp32/main/time-util.h b/examples/wifi-echo/server/esp32/main/time-util.h new file mode 100644 index 00000000000000..5f6d6bab3ea16f --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/time-util.h @@ -0,0 +1,163 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief + ******************************************************************************* + ******************************************************************************/ + +#ifndef __TIME_UTIL_H__ +#define __TIME_UTIL_H__ + +#define SECONDS_IN_MINUTE 60 +#define SECONDS_IN_HOUR 3600 +#define SECONDS_IN_DAY (SECONDS_IN_MINUTE * 60 * 24) +#define SECONDS_IN_WEEK (SECONDS_IN_DAY * 7) +#define DURATION_FOREVER_U32 0xFFFFFFFFU + +/** + * @brief ZCL Date comparison function. + * The results are undefined for dates that contain the do not care value + * in any of the subfields. + * @return -1, if val1 is smaller + * 0, if they are the same + * 1, if val2 is smaller + */ +int8_t emberAfCompareDates(EmberAfDate* date1, EmberAfDate* date2); + +/** + * @brief function that copies a ZigBee Date into a buffer + */ +void emberAfCopyDate(uint8_t *data, uint16_t index, EmberAfDate *src); + +/** + * @brief Decode the given uint32_t into a ZCL Date object where + * the uint32_t is formatted as follows: + * + * (0xFF000000 & value) = year + * (0x00FF0000 & value) = month + * (0x0000FF00 & value) = day of month + * (0x000000FF & value) = day of week + * + */ +void emberAfDecodeDate(uint32_t src, EmberAfDate* dest); + +/** + * @brief Encode and return the given ZCL Date object as an uint32_t. + * Refer to emberAFDecodeDate for details on how the information is stored + * within an uint32_t. + */ +uint32_t emberAfEncodeDate(EmberAfDate* date); + +/** + * @brief Fills the a time structure based on the passed UTC time. + * + */ +void emberAfFillTimeStructFromUtc(uint32_t utcTime, + EmberAfTimeStruct* returnTime); +/** + * @brief Returns the number of days in the month specified in the EmberAfTimeStruct. + * + */ +uint8_t emberAfGetNumberDaysInMonth(EmberAfTimeStruct *time); + +/** + * @brief Calculate a UTC time from the passed time structure. + * + */ +uint32_t emberAfGetUtcFromTimeStruct(EmberAfTimeStruct *time); + +/** + * @brief Determine the week day (Monday=0 ... Sunday=6) based on + * a specified UTC time. + */ +uint8_t emberAfGetWeekdayFromUtc(uint32_t utcTime); + +/* + * @brief Prints out a human readable date form from the given ZCL data type. + */ +void emberAfPrintDate(const EmberAfDate * date); +void emberAfPrintDateln(const EmberAfDate * date); + +/** + * @brief Sets current time. + * Convenience function for setting the time to a value. + * If the time server cluster is implemented on this device, + * then this call will be passed along to the time cluster server + * which will update the time. Otherwise the emberAfSetTimeCallback + * is called, which in the case of the stub does nothing. + * + * @param utcTime: A ZigBee time, the number of seconds since the + * year 2000. + */ +void emberAfSetTime(uint32_t utcTime); + +/** + * @brief Retrieves current time. + * + * Convienience function for retrieving the current time. + * If the time server cluster is implemented, then the time + * is retrieved from that cluster's time attribute. Otherwise, + * the emberAfGetCurrentTimeCallback is called. + * + * A real time is expected to in the ZigBee time format, the number + * of seconds since the year 2000. + */ +uint32_t emberAfGetCurrentTime(void); + +/** + * @brief Prints time. + * + * Convenience function for all clusters to print time. + * This function expects to be passed a ZigBee time which + * is the number of seconds since the year 2000. If + * EMBER_AF_PRINT_CORE is defined, this function will print + * a human readable time from the passed value. If not, this + * function will print nothing. + * + * @param utcTime: A ZigBee time, the number of seconds since the + * year 2000. + */ +void emberAfPrintTime(uint32_t utcTime); + +/** + * @brief Prints the time in ISO 8601 format + * yyyy-mm-dd hh:mm:ss + * + * @param utcTime: A ZigBee time, the number of seconds since the + * year 2000. + */ +void emberAfPrintTimeIsoFormat(uint32_t utcTime); + +#endif // __TIME_UTIL_H__ diff --git a/examples/wifi-echo/server/esp32/main/types_stub.h b/examples/wifi-echo/server/esp32/main/types_stub.h new file mode 100644 index 00000000000000..d2a2cffc8202c6 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/types_stub.h @@ -0,0 +1,1945 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************/ +/** + * @file + * @brief This is a stub file for types that are external to the ZCL + * application framework. These can be redefined/modified as needed in + * the CHIP project + ******************************************************************************/ + +/** + * @brief Defines binding types. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberBindingType +#else +typedef uint8_t EmberBindingType; +enum +#endif +{ + /** A binding that is currently not in use. */ + EMBER_UNUSED_BINDING = 0, + /** A unicast binding whose 64-bit identifier is the destination EUI64. */ + EMBER_UNICAST_BINDING = 1, + /** A unicast binding whose 64-bit identifier is the many-to-one + * destination EUI64. Route discovery should be disabled when sending + * unicasts via many-to-one bindings. */ + EMBER_MANY_TO_ONE_BINDING = 2, + /** A multicast binding whose 64-bit identifier is the group address. This + * binding can be used to send messages to the group and to receive + * messages sent to the group. */ + EMBER_MULTICAST_BINDING = 3, +}; +/** @brief The type of method used for joining. + * + */ + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberJoinMethod +#else +typedef uint8_t EmberJoinMethod; +enum +#endif +{ + /** Devices normally use MAC association to join a network, which respects + * the "permit joining" flag in the MAC beacon. + * This value should be used by default. + */ + EMBER_USE_MAC_ASSOCIATION = 0, + + /** For networks where the "permit joining" flag is never turned + * on, devices will need to use a ZigBee NWK Rejoin. This value causes the + * rejoin to be sent withOUT NWK security and the Trust Center will be + * asked to send the NWK key to the device. The NWK key sent to the device + * can be encrypted with the device's corresponding Trust Center link key. + * That is determined by the ::EmberJoinDecision on the Trust Center + * returned by the ::emberTrustCenterJoinHandler(). + */ + EMBER_USE_NWK_REJOIN = 1, + + /* For networks where the "permit joining" flag is never turned + * on, devices will need to use a NWK Rejoin. If those devices have been + * preconfigured with the NWK key (including sequence number), they can use + * a secured rejoin. This is only necessary for end devices since they need + * a parent. Routers can simply use the ::EMBER_USE_CONFIGURED_NWK_STATE + * join method below. + */ + EMBER_USE_NWK_REJOIN_HAVE_NWK_KEY = 2, + + /** For networks where all network and security information is known + ahead of time, a router device may be commissioned such that it does + not need to send any messages to begin communicating on the network. + */ + EMBER_USE_CONFIGURED_NWK_STATE = 3, +}; + +/** + * @brief Type of Ember software version + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberVersionType +#else +typedef uint8_t EmberVersionType; +enum +#endif +{ + EMBER_VERSION_TYPE_PRE_RELEASE = 0x00, + + //Alpha, should be used rarely + EMBER_VERSION_TYPE_ALPHA_1 = 0x11, + EMBER_VERSION_TYPE_ALPHA_2 = 0x12, + EMBER_VERSION_TYPE_ALPHA_3 = 0x13, + // Leave space in case we decide to add other types in the future. + EMBER_VERSION_TYPE_BETA_1 = 0x21, + EMBER_VERSION_TYPE_BETA_2 = 0x22, + EMBER_VERSION_TYPE_BETA_3 = 0x23, + + // Anything other than 0xAA is considered pre-release + // Silicon Labs may define other types in the future (e.g. beta, alpha) + // Silicon Labs chose an arbitrary number (0xAA) to allow for expansion, but + // to prevent ambiguity in case 0x00 or 0xFF is accidentally retrieved + // as the version type. + EMBER_VERSION_TYPE_GA = 0xAA, +}; + +/** + * @brief Either marks an event as inactive or specifies the units for the + * event execution time. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberEventUnits +#else +typedef uint8_t EmberEventUnits; +enum +#endif +{ + /** The event is not scheduled to run. */ + EMBER_EVENT_INACTIVE = 0, + /** The execution time is in approximate milliseconds. */ + EMBER_EVENT_MS_TIME, + /** The execution time is in 'binary' quarter seconds (256 timer ticks). */ + EMBER_EVENT_QS_TIME, + /** The execution time is in 'binary' minutes (65536 timer ticks). */ + EMBER_EVENT_MINUTE_TIME, + /** The event is scheduled to run at the earliest opportunity. */ + EMBER_EVENT_ZERO_DELAY +}; +/** @brief An identifier for a task */ +typedef uint8_t EmberTaskId; + +/** + * @brief Options to use when sending a message. + * + * The discover-route, APS-retry, and APS-indirect options may be used together. + * Poll response cannot be combined with any other options. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberApsOption +#else +typedef uint16_t EmberApsOption; +enum +#endif +{ + /** No options. */ + EMBER_APS_OPTION_NONE = 0x0000, + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + EMBER_APS_OPTION_ENCRYPT_WITH_TRANSIENT_KEY = 0x0001, + EMBER_APS_OPTION_USE_ALIAS_SEQUENCE_NUMBER = 0x0002, +#endif + + /** This signs the application layer message body (APS Frame not included) + and appends the ECDSA signature to the end of the message, which is needed by + Smart Energy applications and requires the CBKE and ECC libraries. + The ::emberDsaSignHandler() function is called after DSA signing + is complete but before the message has been sent by the APS layer. + Note that when passing a buffer to the stack for DSA signing, the final + byte in the buffer has a special significance as an indicator of how many + leading bytes should be ignored for signature purposes. See the API + documentation of emberDsaSign() or the dsaSign EZSP command for more + details about this requirement. + */ + EMBER_APS_OPTION_DSA_SIGN = 0x0010, + /** Send the message using APS Encryption using the Link Key shared + with the destination node to encrypt the data at the APS Level. */ + EMBER_APS_OPTION_ENCRYPTION = 0x0020, + /** Resend the message using the APS retry mechanism. + This option and the enable route discovery option must be enabled for + an existing route to be repaired automatically. */ + EMBER_APS_OPTION_RETRY = 0x0040, + /** Send the message with the NWK 'enable route discovery' flag, which + causes a route discovery to be initiated if no route to the destination + is known. Note that in the mesh stack, this option and the APS retry + option must be enabled an existing route to be repaired + automatically. */ + EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY = 0x0100, + /** Send the message with the NWK 'force route discovery' flag, which causes + a route discovery to be initiated even if one is known. */ + EMBER_APS_OPTION_FORCE_ROUTE_DISCOVERY = 0x0200, + /** Include the source EUI64 in the network frame. */ + EMBER_APS_OPTION_SOURCE_EUI64 = 0x0400, + /** Include the destination EUI64 in the network frame. */ + EMBER_APS_OPTION_DESTINATION_EUI64 = 0x0800, + /** Send a ZDO request to discover the node ID of the destination if it is + not already known. */ + EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY = 0x1000, + /** This message is being sent in response to a call to + ::emberPollHandler(). It causes the message to be sent + immediately instead of being queued up until the next poll from the + (end device) destination. */ + EMBER_APS_OPTION_POLL_RESPONSE = 0x2000, + /** This incoming message is a valid ZDO request and the application + * is responsible for sending a ZDO response. This flag is used only + * within emberIncomingMessageHandler() when + * EMBER_APPLICATION_RECEIVES_UNSUPPORTED_ZDO_REQUESTS is defined. */ + EMBER_APS_OPTION_ZDO_RESPONSE_REQUIRED = 0x4000, + /** This message is part of a fragmented message. This option may only + be set for unicasts. The groupId field gives the index of this + fragment in the low-order byte. If the low-order byte is zero this + is the first fragment and the high-order byte contains the number + of fragments in the message. */ + EMBER_APS_OPTION_FRAGMENT = 0x8000 +}; + + +/** @brief An in-memory representation of a ZigBee APS frame + * of an incoming or outgoing message. + */ +typedef struct { + /** The application profile ID that describes the format of the message. */ + uint16_t profileId; + /** The cluster ID for this message. */ + uint16_t clusterId; + /** The source endpoint. */ + uint8_t sourceEndpoint; + /** The destination endpoint. */ + uint8_t destinationEndpoint; + /** A bitmask of options from the enumeration above. */ + EmberApsOption options; + /** The group ID for this message, if it is multicast mode. */ + uint16_t groupId; + /** The sequence number. */ + uint8_t sequence; + uint8_t radius; +} EmberApsFrame; + +/** + * @brief EUI 64-bit ID (an IEEE address). + */ +typedef uint8_t EmberEUI64[EUI64_SIZE]; + +/** + * @brief 16-bit ZigBee network address. + */ +typedef uint16_t EmberNodeId; + +/** + * @brief 802.15.4 PAN ID. + */ +typedef uint16_t EmberPanId; + +/** @brief 16-bit ZigBee multicast group identifier. */ +typedef uint16_t EmberMulticastId; + +/** @brief This enumeration determines whether or not a Trust Center + * answers trust center link key requests. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberTcLinkKeyRequestPolicy +#else +typedef uint8_t EmberTcLinkKeyRequestPolicy; +enum +#endif +{ + EMBER_DENY_TC_LINK_KEY_REQUESTS = 0x00, + EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY = 0x01, + // When using the following mode a unique random link key is created. + // The key which is generated due to this mode is added to the link + // key table. Therefore make sure that the link key table size is not + // zero as this can result in the newly generated key not being saved + // and communication breaking between the trust center and the nodes. + EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_GENERATE_NEW_KEY = 0x02 +}; + +/** @brief This enumeration determines whether or not a Trust Center + * answers app link key requests. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberAppLinkKeyRequestPolicy +#else +typedef uint8_t EmberAppLinkKeyRequestPolicy; +enum +#endif +{ + EMBER_DENY_APP_LINK_KEY_REQUESTS = 0x00, + EMBER_ALLOW_APP_LINK_KEY_REQUEST = 0x01 +}; + + +/** @brief This is the Extended Security Bitmask that controls the use + * of various extended security features. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberExtendedSecurityBitmask +#else +typedef uint16_t EmberExtendedSecurityBitmask; +enum +#endif +{ +#ifndef DOXYGEN_SHOULD_SKIP_THIS + // If this bit is set, the 'key token data' field is set in the Initial + // Security Bitmask to 0 (No Preconfig Key token). Otherwise, the + // field is left as is. + EMBER_PRECONFIG_KEY_NOT_VALID = 0x0001, +#endif + + // bits 2-3 are unused. + /** This denotes that the network key update can only happen if the network + key update request is unicast and encrypted i.e. broadcast network key update + requests will not be processed if bit 1 is set*/ + EMBER_SECURE_NETWORK_KEY_ROTATION = 0x0002, + + /** This denotes whether a joiner node (router or end-device) uses a Global + Link Key or a Unique Link Key. */ + EMBER_JOINER_GLOBAL_LINK_KEY = 0x0010, + + /** This denotes whether the device's outgoing frame counter is allowed to + be reset during forming or joining. If the flag is set, the outgoing frame + counter is not allowed to be reset. If the flag is not set, the frame + counter is allowed to be reset. */ + + EMBER_EXT_NO_FRAME_COUNTER_RESET = 0x0020, + + /** This denotes whether a device should discard or accept network leave + without rejoin commands. */ + EMBER_NWK_LEAVE_WITHOUT_REJOIN_NOT_ALLOWED = 0x0040, + + // Bit 7 reserved for future use (stored in TOKEN). + + /** This denotes whether a router node should discard or accept network Leave + Commands. */ + EMBER_NWK_LEAVE_REQUEST_NOT_ALLOWED = 0x0100, + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + /** This denotes whether a node is running the latest stack specification or + is emulating R18 specs behavior. If this flag is enabled, a router + node should only send encrypted Update Device messages while the TC should + only accept encrypted Updated Device messages.*/ + EMBER_R18_STACK_BEHAVIOR = 0x0200, +#endif + + // Bit 10 is reserved for future use (stored in TOKEN). + // Bit 11 is reserved for future use(stored in RAM). + // Bits 12-15 are unused. +}; + +/** @brief This data structure contains the key data that is passed + * into various other functions. */ +typedef struct { + /** This is the key byte data. */ + uint8_t contents[EMBER_ENCRYPTION_KEY_SIZE]; +} EmberKeyData; +/** + * @brief Defines the possible types of nodes and the roles that a + * node might play in a network. + */ + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberNodeType +#else +typedef uint8_t EmberNodeType; +enum +#endif +{ + /** The device is not joined. */ + EMBER_UNKNOWN_DEVICE = 0, + /** Will relay messages and can act as a parent to other nodes. */ + EMBER_COORDINATOR = 1, + /** Will relay messages and can act as a parent to other nodes. */ + EMBER_ROUTER = 2, + /** Communicates only with its parent and will not relay messages. */ + EMBER_END_DEVICE = 3, + /** An end device whose radio can be turned off to save power. + * The application must call ::emberPollForData() to receive messages. + */ + EMBER_SLEEPY_END_DEVICE = 4, +}; + +/** + * @brief Defines the possible incoming message types. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberIncomingMessageType +#else +typedef uint8_t EmberIncomingMessageType; +enum +#endif +{ + /** Unicast. */ + EMBER_INCOMING_UNICAST, + /** Unicast reply. */ + EMBER_INCOMING_UNICAST_REPLY, + /** Multicast. */ + EMBER_INCOMING_MULTICAST, + /** Multicast sent by the local device. */ + EMBER_INCOMING_MULTICAST_LOOPBACK, + /** Broadcast. */ + EMBER_INCOMING_BROADCAST, + /** Broadcast sent by the local device. */ + EMBER_INCOMING_BROADCAST_LOOPBACK +}; + +/** + * @brief Defines the possible outgoing message types. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberOutgoingMessageType +#else +typedef uint8_t EmberOutgoingMessageType; +enum +#endif +{ + /** Unicast sent directly to an EmberNodeId. */ + EMBER_OUTGOING_DIRECT, + /** Unicast sent using an entry in the address table. */ + EMBER_OUTGOING_VIA_ADDRESS_TABLE, + /** Unicast sent using an entry in the binding table. */ + EMBER_OUTGOING_VIA_BINDING, + /** Multicast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_MULTICAST, + /** An aliased multicast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_MULTICAST_WITH_ALIAS, + /** An aliased Broadcast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_BROADCAST_WITH_ALIAS, + /** A broadcast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_BROADCAST +}; + +/** + * @brief Size of EUI64 (an IEEE address) in bytes (8). + */ +#define EUI64_SIZE 8 + +/** + * @brief Size of an encryption key in bytes (16). + */ +#define EMBER_ENCRYPTION_KEY_SIZE 16 + +/** + * @brief Size of an extended PAN identifier in bytes (8). + */ +#define EXTENDED_PAN_ID_SIZE 8 + + +/** @brief Endpoint information (a ZigBee Simple Descriptor). + * + * This is a ZigBee Simple Descriptor and contains information + * about an endpoint. This information is shared with other nodes in the + * network by the ZDO. + */ + +typedef struct { + /** Identifies the endpoint's application profile. */ + uint16_t profileId; + /** The endpoint's device ID within the application profile. */ + uint16_t deviceId; + /** The endpoint's device version. */ + uint8_t deviceVersion; + /** The number of input clusters. */ + uint8_t inputClusterCount; + /** The number of output clusters. */ + uint8_t outputClusterCount; +} EmberEndpointDescription; + +/** @brief A type of packet received by the stack + * + * This enum provides a way to indicate which protocol layer in the Ember + * stack an incoming packet is meant for, or from which protocol layer + * an outgoing command is being sent from. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberZigbeePacketType +#else +typedef uint8_t EmberZigbeePacketType; +enum +#endif +{ + /** Describes an 802.15.4 raw MAC message, unprocessed by the stack. */ + EMBER_ZIGBEE_PACKET_TYPE_RAW_MAC, + /** Describes an 802.15.4 MAC layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_MAC_COMMAND, + /** Describes a ZigBee Network layer data message. */ + EMBER_ZIGBEE_PACKET_TYPE_NWK_DATA, + /** Describes a ZigBee Network layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_NWK_COMMAND, + /** Describes a ZigBee Application Support layer data message. */ + EMBER_ZIGBEE_PACKET_TYPE_APS_DATA, + /** Describes a ZigBee Application Support layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_APS_COMMAND, + /** Describes a ZigBee Device Object command. */ + EMBER_ZIGBEE_PACKET_TYPE_ZDO, + /** Describes a ZigBee Cluster Library command. */ + EMBER_ZIGBEE_PACKET_TYPE_ZCL, + + /** Distinguishing between raw MAC and beacons for simplicity */ + EMBER_ZIGBEE_PACKET_TYPE_BEACON, +}; + +/** + * @brief Defines a ZigBee network and the associated parameters. + */ +typedef struct { + uint16_t panId; + uint8_t channel; + bool allowingJoin; + uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; + uint8_t stackProfile; + uint8_t nwkUpdateId; +} EmberZigbeeNetwork; + +/** @brief indication of the action taken on a packet */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberPacketAction +#else +typedef uint8_t EmberPacketAction; +enum +#endif +{ + EMBER_DROP_PACKET = 0, + EMBER_ACCEPT_PACKET = 1, + EMBER_MANGLE_PACKET, +}; + +/** + * @name ZigBee Device Object (ZDO) Definitions + */ +//@{ + +/** @name ZDO response status. + * + * Most responses to ZDO commands contain a status byte. + * The meaning of this byte is defined by the ZigBee Device Profile. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberZdoStatus +#else +typedef uint8_t EmberZdoStatus; +enum +#endif +{ + // These values are taken from Table 48 of ZDP Errata 043238r003 and Table 2 + // of NWK 02130r10. + EMBER_ZDP_SUCCESS = 0x00, + // 0x01 to 0x7F are reserved + EMBER_ZDP_INVALID_REQUEST_TYPE = 0x80, + EMBER_ZDP_DEVICE_NOT_FOUND = 0x81, + EMBER_ZDP_INVALID_ENDPOINT = 0x82, + EMBER_ZDP_NOT_ACTIVE = 0x83, + EMBER_ZDP_NOT_SUPPORTED = 0x84, + EMBER_ZDP_TIMEOUT = 0x85, + EMBER_ZDP_NO_MATCH = 0x86, + // 0x87 is reserved = 0x87, + EMBER_ZDP_NO_ENTRY = 0x88, + EMBER_ZDP_NO_DESCRIPTOR = 0x89, + EMBER_ZDP_INSUFFICIENT_SPACE = 0x8a, + EMBER_ZDP_NOT_PERMITTED = 0x8b, + EMBER_ZDP_TABLE_FULL = 0x8c, + EMBER_ZDP_NOT_AUTHORIZED = 0x8d, + EMBER_ZDP_DEVICE_BINDING_TABLE_FULL = 0x8e, + EMBER_ZDP_INVALID_INDEX = 0x8f, + + EMBER_NWK_ALREADY_PRESENT = 0xC5, + EMBER_NWK_TABLE_FULL = 0xC7, + EMBER_NWK_UNKNOWN_DEVICE = 0xC8 +}; + + +/** @brief Defines an entry in the binding table. + * + * A binding entry specifies a local endpoint, a remote endpoint, a + * cluster ID and either the destination EUI64 (for unicast bindings) or the + * 64-bit group address (for multicast bindings). + */ +typedef struct { + /** The type of binding. */ + EmberBindingType type; + /** The endpoint on the local node. */ + uint8_t local; + /** A cluster ID that matches one from the local endpoint's simple descriptor. + * This cluster ID is set by the provisioning application to indicate which + * part an endpoint's functionality is bound to this particular remote node + * and is used to distinguish between unicast and multicast bindings. Note + * that a binding can be used to to send messages with any cluster ID, not + * just that listed in the binding. + */ + uint16_t clusterId; + /** The endpoint on the remote node (specified by \c identifier). */ + uint8_t remote; + /** A 64-bit identifier. This is either: + * - The destination EUI64, for unicasts. + * - A 16-bit multicast group address, for multicasts. + */ + EmberEUI64 identifier; + /** The index of the network the binding belongs to. */ + uint8_t networkIndex; +} EmberBindingTableEntry; + + +/** @brief This describes the Initial Security features and requirements that + * will be used when forming or joining the network. */ +typedef struct { + /** This bitmask enumerates which security features should be used + and the presence of valid data within other elements of the + ::EmberInitialSecurityState data structure. For more details, see the + ::EmberInitialSecurityBitmask. */ + uint16_t bitmask; + /** This is the pre-configured key that can be used by devices when joining the + * network if the Trust Center does not send the initial security data + * in-the-clear. + * For the Trust Center, it will be the global link key and must be set + * regardless of whether joining devices are expected to have a pre-configured + * Link Key. + * This parameter will only be used if the EmberInitialSecurityState::bitmask + * sets the bit indicating ::EMBER_HAVE_PRECONFIGURED_KEY. */ + EmberKeyData preconfiguredKey; + /** This is the Network Key used when initially forming the network. + * It must be set on the Trust Center and is not needed for devices + * joining the network. This parameter will only be used if the + * EmberInitialSecurityState::bitmask sets the bit indicating + * ::EMBER_HAVE_NETWORK_KEY. */ + EmberKeyData networkKey; + /** This is the sequence number associated with the network key. It must + * be set if the Network Key is set and is used to indicate a particular + * of the network key for updating and switching. This parameter will + * only be used if the ::EMBER_HAVE_NETWORK_KEY is set. Generally, it should + * be set to 0 when forming the network; joining devices can ignore + * this value. */ + uint8_t networkKeySequenceNumber; + /** This is the long address of the trust center on the network that will + * be joined. It is usually NOT set prior to joining the network and + * is learned during the joining message exchange. This field + * is only examined if ::EMBER_HAVE_TRUST_CENTER_EUI64 is set in the + * EmberInitialSecurityState::bitmask. Most devices should clear that + * bit and leave this field alone. This field must be set when using + * commissioning mode. It is required to be in little-endian format. */ + EmberEUI64 preconfiguredTrustCenterEui64; +} EmberInitialSecurityState; + +/** @brief The Status of the Update Device message sent to the Trust Center. + * The device may have joined or rejoined insecurely, rejoined securely, or + * left. MAC Security has been deprecated and therefore there is no secure + * join. + */ +// These map to the actual values within the APS Command frame so they cannot +// be arbitrarily changed. +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberDeviceUpdate +#else +typedef uint8_t EmberDeviceUpdate; +enum +#endif +{ + EMBER_STANDARD_SECURITY_SECURED_REJOIN = 0, + EMBER_STANDARD_SECURITY_UNSECURED_JOIN = 1, + EMBER_DEVICE_LEFT = 2, + EMBER_STANDARD_SECURITY_UNSECURED_REJOIN = 3, +}; + +/** + * @brief The decision made by the Trust Center when a node attempts to join. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberJoinDecision +#else +typedef uint8_t EmberJoinDecision; +enum +#endif +{ + /** Allow the node to join. The node has the key. */ + EMBER_USE_PRECONFIGURED_KEY = 0, + /** Allow the node to join. Send the key to the node. */ + EMBER_SEND_KEY_IN_THE_CLEAR, + /** Deny join. */ + EMBER_DENY_JOIN, + /** Take no action. */ + EMBER_NO_ACTION +}; + +/** @brief This denotes the status of an attempt to establish + * a key with another device. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberKeyStatus +#else +typedef uint8_t EmberKeyStatus; +enum +#endif +{ + EMBER_KEY_STATUS_NONE = 0x00, + EMBER_APP_LINK_KEY_ESTABLISHED = 0x01, + EMBER_TRUST_CENTER_LINK_KEY_ESTABLISHED = 0x03, + + EMBER_KEY_ESTABLISHMENT_TIMEOUT = 0x04, + EMBER_KEY_TABLE_FULL = 0x05, + + // These are success status values applying only to the + // Trust Center answering key requests. + EMBER_TC_RESPONDED_TO_KEY_REQUEST = 0x06, + EMBER_TC_APP_KEY_SENT_TO_REQUESTER = 0x07, + + // These are failure status values applying only to the + // Trust Center answering key requests. + EMBER_TC_RESPONSE_TO_KEY_REQUEST_FAILED = 0x08, + EMBER_TC_REQUEST_KEY_TYPE_NOT_SUPPORTED = 0x09, + EMBER_TC_NO_LINK_KEY_FOR_REQUESTER = 0x0A, + EMBER_TC_REQUESTER_EUI64_UNKNOWN = 0x0B, + EMBER_TC_RECEIVED_FIRST_APP_KEY_REQUEST = 0x0C, + EMBER_TC_TIMEOUT_WAITING_FOR_SECOND_APP_KEY_REQUEST = 0x0D, + EMBER_TC_NON_MATCHING_APP_KEY_REQUEST_RECEIVED = 0x0E, + EMBER_TC_FAILED_TO_SEND_APP_KEYS = 0x0F, + EMBER_TC_FAILED_TO_STORE_APP_KEY_REQUEST = 0x10, + EMBER_TC_REJECTED_APP_KEY_REQUEST = 0x11, + EMBER_TC_FAILED_TO_GENERATE_NEW_KEY = 0x12, + EMBER_TC_FAILED_TO_SEND_TC_KEY = 0x13, + + // These are generic status values for a key requester. + EMBER_TRUST_CENTER_IS_PRE_R21 = 0x1E, + + // These are status values applying only to the Trust Center + // verifying link keys. + EMBER_TC_REQUESTER_VERIFY_KEY_TIMEOUT = 0x32, + EMBER_TC_REQUESTER_VERIFY_KEY_FAILURE = 0x33, + EMBER_TC_REQUESTER_VERIFY_KEY_SUCCESS = 0x34, + + // These are status values applying only to the key requester + // verifying link keys. + EMBER_VERIFY_LINK_KEY_FAILURE = 0x64, + EMBER_VERIFY_LINK_KEY_SUCCESS = 0x65, +}; + +typedef uint8_t EmberAfPluginNetworkSteeringJoiningState; + +enum SleepModes +#else +typedef uint8_t SleepModes; +enum +#endif +{ + SLEEPMODE_IDLE = 1, +}; + +/** + * @brief Defines the possible join states for a node. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberNetworkStatus +#else +typedef uint8_t EmberNetworkStatus; +enum +#endif +{ + /** The node is not associated with a network in any way. */ + EMBER_NO_NETWORK, + /** The node is currently attempting to join a network. */ + EMBER_JOINING_NETWORK, + /** The node is joined to a network. */ + EMBER_JOINED_NETWORK, + /** The node is an end device joined to a network but its parent + is not responding. */ + EMBER_JOINED_NETWORK_NO_PARENT, + /** The node is in the process of leaving its current network. */ + EMBER_LEAVING_NETWORK +}; + +/** @brief Holds network parameters. + * + * For information about power settings and radio channels, + * see the technical specification for the + * RF communication module in your Developer Kit. + */ +typedef struct { + /** The network's extended PAN identifier.*/ + uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; + /** The network's PAN identifier.*/ + uint16_t panId; + /** A power setting, in dBm.*/ + int8_t radioTxPower; + /** A radio channel. Be sure to specify a channel supported by the radio. */ + uint8_t radioChannel; + /** Join method: The protocol messages used to establish an initial parent. It is + * ignored when forming a ZigBee network, or when querying the stack for its + network parameters. + */ + EmberJoinMethod joinMethod; + + /** NWK Manager ID. The ID of the network manager in the current network. + This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE + as the join method. + */ + EmberNodeId nwkManagerId; + /** An NWK Update ID. The value of the ZigBee nwkUpdateId known by the stack. + It is used to determine the newest instance of the network after a PAN + ID or channel change. This may only be set at joining when using + EMBER_USE_CONFIGURED_NWK_STATE as the join method. + */ + uint8_t nwkUpdateId; + /** The NWK channel mask. The list of preferred channels that the NWK manager + has told this device to use when searching for the network. + This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE + as the join method. + */ + uint32_t channels; +} EmberNetworkParameters; + +/** + * @brief Incoming and outgoing messages are stored in buffers. + * These buffers are allocated and freed as needed. + * + * Buffers are 32 bytes in length and can be linked together to hold + * longer messages. + * + * See packet-buffer.h for APIs related to stack and linked buffers. + */ +typedef uint8_t EmberMessageBuffer; + +/** + * @brief A version structure containing all version information. + */ +typedef struct { + uint16_t build; + uint8_t major; + uint8_t minor; + uint8_t patch; + uint8_t special; + EmberVersionType type; +} EmberVersion; + +/** @brief This structure contains information about child nodes. + * + */ +typedef struct { + EmberEUI64 eui64; + EmberNodeType type; + EmberNodeId id; + uint8_t phy; + uint8_t power; + uint8_t timeout; +} EmberChildData; + +/** + * @brief The profile ID used to address all the public profiles. + */ +#define EMBER_WILDCARD_PROFILE_ID 0xFFFF + +/** + * @brief The maximum value for a profile ID in the standard profile range. + */ +#define EMBER_MAXIMUM_STANDARD_PROFILE_ID 0x7FFF + +/** + * @brief A distinguished network ID that will never be assigned + * to any node. This value is used when getting the remote node ID + * from the address or binding tables. It indicates that the address + * or binding table entry is currently in use but the node ID + * corresponding to the EUI64 in the table is currently unknown. + */ +#define EMBER_UNKNOWN_NODE_ID 0xFFFD + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberStatus +#else +enum +#endif //DOXYGEN_SHOULD_SKIP_THIS +{ +/** + * @name Generic Messages + * These messages are system wide. + */ +//@{ + +/** + * @brief The generic "no error" message. + */ + EMBER_SUCCESS = 0x00, + +/** + * @brief The generic "fatal error" message. + */ + EMBER_ERR_FATAL = 0x01, + +/** + * @brief An invalid value was passed as an argument to a function. + */ + EMBER_BAD_ARGUMENT = 0x02, + +/** + * @brief The requested information was not found. + */ + EMBER_NOT_FOUND = 0x03, + +/** + * @brief The manufacturing and stack token format in non-volatile memory + * is different than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_MFG_STACK_VERSION_MISMATCH = 0x04, + +/** + * @brief The static memory definitions in ember-static-memory.h + * are incompatible with this stack version. + */ + EMBER_INCOMPATIBLE_STATIC_MEMORY_DEFINITIONS = 0x05, + +/** + * @brief The manufacturing token format in non-volatile memory is + * different than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_MFG_VERSION_MISMATCH = 0x06, + +/** + * @brief The stack token format in non-volatile memory is different + * than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_STACK_VERSION_MISMATCH = 0x07, + +//@} // END Generic Messages + +/** + * @name Packet Buffer Module Errors + */ +//@{ + +/** + * @brief There are no more buffers. + */ + EMBER_NO_BUFFERS = 0x18, + +//@} / END Packet Buffer Module Errors + +/** + * @name Serial Manager Errors + */ +//@{ + +/** + * @brief Specifies an invalid baud rate. + */ + EMBER_SERIAL_INVALID_BAUD_RATE = 0x20, + +/** + * @brief Specifies an invalid serial port. + */ + EMBER_SERIAL_INVALID_PORT = 0x21, + +/** + * @brief Tried to send too much data. + */ + EMBER_SERIAL_TX_OVERFLOW = 0x22, + +/** + * @brief There wasn't enough space to store a received character + * and the character was dropped. + */ + EMBER_SERIAL_RX_OVERFLOW = 0x23, + +/** + * @brief Detected a UART framing error. + */ + EMBER_SERIAL_RX_FRAME_ERROR = 0x24, + +/** + * @brief Detected a UART parity error. + */ + EMBER_SERIAL_RX_PARITY_ERROR = 0x25, + +/** + * @brief There is no received data to process. + */ + EMBER_SERIAL_RX_EMPTY = 0x26, + +/** + * @brief The receive interrupt was not handled in time and a + * character was dropped. + */ + EMBER_SERIAL_RX_OVERRUN_ERROR = 0x27, + +//@} + +/** + * @name MAC Errors + */ +//@{ + +/** + * @brief The MAC transmit queue is full. + */ + EMBER_MAC_TRANSMIT_QUEUE_FULL = 0x39, +// Internal + +/** + * @brief MAC header FCF error on receive. + */ + EMBER_MAC_UNKNOWN_HEADER_TYPE = 0x3A, + +/** + * @brief MAC ACK header received. + */ + EMBER_MAC_ACK_HEADER_TYPE = 0x3B, + +/** + * @brief The MAC can't complete this task because it is scanning. + */ + EMBER_MAC_SCANNING = 0x3D, + +/** + * @brief No pending data exists for a data poll. + */ + EMBER_MAC_NO_DATA = 0x31, + +/** + * @brief Attempts to scan when joined to a network. + */ + EMBER_MAC_JOINED_NETWORK = 0x32, + +/** + * @brief Scan duration must be 0 to 14 inclusive. Tried to + * scan with an incorrect duration value. + */ + EMBER_MAC_BAD_SCAN_DURATION = 0x33, + +/** + * @brief emberStartScan was called with an incorrect scan type. + */ + EMBER_MAC_INCORRECT_SCAN_TYPE = 0x34, + +/** + * @brief emberStartScan was called with an invalid channel mask. + */ + EMBER_MAC_INVALID_CHANNEL_MASK = 0x35, + +/** + * @brief Failed to scan the current channel because + * the relevant MAC command could not be transmitted. + */ + EMBER_MAC_COMMAND_TRANSMIT_FAILURE = 0x36, + +/** + * @brief An ACK was expected following the transmission but + * the MAC level ACK was never received. + */ + EMBER_MAC_NO_ACK_RECEIVED = 0x40, + +/** + * @brief MAC failed to transmit a message because it could not successfully + * perform a radio network switch. + */ + EMBER_MAC_RADIO_NETWORK_SWITCH_FAILED = 0x41, + +/** + * @brief An indirect data message timed out before a poll requested it. + */ + EMBER_MAC_INDIRECT_TIMEOUT = 0x42, + +//@} + +/** + * @name Simulated EEPROM Errors + */ +//@{ + +/** + * @brief The Simulated EEPROM is telling the application that + * at least one flash page to be erased. The GREEN status means the + * current page has not filled above the ::ERASE_CRITICAL_THRESHOLD. + * + * The application should call the function ::halSimEepromErasePage() + * when it can to erase a page. + */ + EMBER_SIM_EEPROM_ERASE_PAGE_GREEN = 0x43, + +/** + * @brief The Simulated EEPROM is telling the application that + * at least one flash page must be erased. The RED status means the + * current page has filled above the ::ERASE_CRITICAL_THRESHOLD. + * + * Due to the shrinking availability of write space, data could + * be lost. The application must call the function ::halSimEepromErasePage() + * as soon as possible to erase a page. + */ + EMBER_SIM_EEPROM_ERASE_PAGE_RED = 0x44, + +/** + * @brief The Simulated EEPROM has run out of room to write new data + * and the data trying to be set has been lost. This error code is the + * result of ignoring the ::SIM_EEPROM_ERASE_PAGE_RED error code. + * + * The application must call the function ::halSimEepromErasePage() to make room for + * any further calls to set a token. + */ + EMBER_SIM_EEPROM_FULL = 0x45, + +// Errors 46 and 47 are now defined below in the +// flash error block (was attempting to prevent renumbering). + +/** + * @brief Attempt 1 to initialize the Simulated EEPROM has failed. + * + * This failure means the information already stored in the Flash (or a lack + * thereof), is fatally incompatible with the token information compiled + * into the code image being run. + */ + EMBER_SIM_EEPROM_INIT_1_FAILED = 0x48, + +/** + * @brief Attempt 2 to initialize the Simulated EEPROM has failed. + * + * This failure means Attempt 1 failed, and the token system failed to + * properly reload default tokens and reset the Simulated EEPROM. + */ + EMBER_SIM_EEPROM_INIT_2_FAILED = 0x49, + +/** + * @brief Attempt 3 to initialize the Simulated EEPROM has failed. + * + * This failure means one or both of the tokens ::TOKEN_MFG_NVDATA_VERSION or + * ::TOKEN_STACK_NVDATA_VERSION were incorrect and the token system failed to + * properly reload default tokens and reset the Simulated EEPROM. + */ + EMBER_SIM_EEPROM_INIT_3_FAILED = 0x4A, + +/** + * @brief The Simulated EEPROM is repairing itself. + * + * While there's nothing for an app to do when the SimEE is going to + * repair itself (SimEE has to be fully functional for the rest of the + * system to work), alert the application to the fact that repair + * is occurring. There are debugging scenarios where an app might want + * to know that repair is happening, such as monitoring frequency. + * @note Common situations will trigger an expected repair, such as + * using an erased chip or changing token definitions. + */ + EMBER_SIM_EEPROM_REPAIRING = 0x4D, + +//@} + +/** + * @name Flash Errors + */ +//@{ + +/** + * @brief A fatal error has occurred while trying to write data to the + * Flash. The target memory attempting to be programmed is already programmed. + * The flash write routines were asked to flip a bit from a 0 to 1, which is + * physically impossible and the write was therefore inhibited. The data in + * the Flash cannot be trusted after this error. + */ + EMBER_ERR_FLASH_WRITE_INHIBITED = 0x46, + +/** + * @brief A fatal error has occurred while trying to write data to the + * Flash and the write verification has failed. Data in the Flash + * cannot be trusted after this error and it is possible this error is the + * result of exceeding the life cycles of the Flash. + */ + EMBER_ERR_FLASH_VERIFY_FAILED = 0x47, + +/** + * @description A fatal error has occurred while trying to write data to the + * Flash possibly due to write protection or an invalid address. Data in + * the Flash cannot be trusted after this error and it is possible this error + * is the result of exceeding the life cycles of the Flash. + */ + EMBER_ERR_FLASH_PROG_FAIL = 0x4B, + +/** + * @description A fatal error has occurred while trying to erase the Flash possibly + * due to write protection. Data in the Flash cannot be trusted after + * this error and it is possible this error is the result of exceeding the + * life cycles of the Flash. + */ + EMBER_ERR_FLASH_ERASE_FAIL = 0x4C, + +//@} + +/** + * @name Bootloader Errors + */ +//@{ + +/** + * @brief The bootloader received an invalid message (failed attempt + * to go into bootloader). + */ + EMBER_ERR_BOOTLOADER_TRAP_TABLE_BAD = 0x58, + +/** + * @brief The bootloader received an invalid message (failed attempt to go + * into the bootloader). + */ + EMBER_ERR_BOOTLOADER_TRAP_UNKNOWN = 0x59, + +/** + * @brief The bootloader cannot complete the bootload operation because + * either an image was not found or the image exceeded memory bounds. + */ + EMBER_ERR_BOOTLOADER_NO_IMAGE = 0x05A, + +//@} + +/** + * @name Transport Errors + */ +//@{ + +/** + * @brief The APS layer attempted to send or deliver a message + * and failed. + */ + EMBER_DELIVERY_FAILED = 0x66, + +/** + * @brief This binding index is out of range for the current binding table. + */ + EMBER_BINDING_INDEX_OUT_OF_RANGE = 0x69, + +/** + * @brief This address table index is out of range for the current + * address table. + */ + EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE = 0x6A, + +/** + * @brief An invalid binding table index was given to a function. + */ + EMBER_INVALID_BINDING_INDEX = 0x6C, + +/** + * @brief The API call is not allowed given the current state of the + * stack. + */ + EMBER_INVALID_CALL = 0x70, + +/** + * @brief The link cost to a node is not known. + */ + EMBER_COST_NOT_KNOWN = 0x71, + +/** + * @brief The maximum number of in-flight messages = i.e., + * ::EMBER_APS_UNICAST_MESSAGE_COUNT, has been reached. + */ + EMBER_MAX_MESSAGE_LIMIT_REACHED = 0x72, + +/** + * @brief The message to be transmitted is too big to fit into a + * single over-the-air packet. + */ + EMBER_MESSAGE_TOO_LONG = 0x74, + +/** + * @brief The application is trying to delete or overwrite a binding + * that is in use. + */ + EMBER_BINDING_IS_ACTIVE = 0x75, + +/** + * @brief The application is trying to overwrite an address table entry + * that is in use. + */ + EMBER_ADDRESS_TABLE_ENTRY_IS_ACTIVE = 0x76, + +/** + * @brief An attempt was made to transmit during the suspend period. + */ + EMBER_TRANSMISSION_SUSPENDED = 0x77, + +//@} +// + +/** + * @name Green Power status codes + */ +//@{ + +/** + * @brief Security match. + */ + EMBER_MATCH = 0x78, +/** + * @brief Drop frame. + */ + EMBER_DROP_FRAME = 0x79, +/** + * @brief + */ + EMBER_PASS_UNPROCESSED = 0x7A, +/** + * @brief + */ + EMBER_TX_THEN_DROP = 0x7B, +/** + * @brief + */ + EMBER_NO_SECURITY = 0x7C, +/** + * @brief + */ + EMBER_COUNTER_FAILURE = 0x7D, +/** + * @brief + */ + EMBER_AUTH_FAILURE = 0x7E, +/** + * @brief + */ + EMBER_UNPROCESSED = 0x7F, + +//@} +// + +/** + * @name HAL Module Errors + */ +//@{ + +/** + * @brief The conversion is complete. + */ + EMBER_ADC_CONVERSION_DONE = 0x80, + +/** + * @brief The conversion cannot be done because a request is being + * processed. + */ + EMBER_ADC_CONVERSION_BUSY = 0x81, + +/** + * @brief The conversion is deferred until the current request has been + * processed. + */ + EMBER_ADC_CONVERSION_DEFERRED = 0x82, + +/** + * @brief No results are pending. + */ + EMBER_ADC_NO_CONVERSION_PENDING = 0x84, + +/** + * @brief Sleeping (for a duration) has been abnormally interrupted + * and exited prematurely. + */ + EMBER_SLEEP_INTERRUPTED = 0x85, + +//@} + +/** + * @name PHY Errors + */ +//@{ + +/** + * @brief The transmit attempt failed because the radio scheduler could not find + * a slot to transmit this packet in or a higher priority event interrupted it. + */ + EMBER_PHY_TX_SCHED_FAIL = 0x87, + +/** + * @brief The transmit hardware buffer underflowed. + */ + EMBER_PHY_TX_UNDERFLOW = 0x88, + +/** + * @brief The transmit hardware did not finish transmitting a packet. + */ + EMBER_PHY_TX_INCOMPLETE = 0x89, + +/** + * @brief An unsupported channel setting was specified. + */ + EMBER_PHY_INVALID_CHANNEL = 0x8A, + +/** + * @brief An unsupported power setting was specified. + */ + EMBER_PHY_INVALID_POWER = 0x8B, + +/** + * @brief The requested operation cannot be completed because the radio + * is currently busy, either transmitting a packet or performing calibration. + */ + EMBER_PHY_TX_BUSY = 0x8C, + +/** + * @brief The transmit attempt failed because all CCA attempts indicated that + * the channel was busy. + */ + EMBER_PHY_TX_CCA_FAIL = 0x8D, + +/** + * @brief The transmit attempt was blocked from going over the air. Typically + * this is due to the Radio Hold Off (RHO) or Coexistence plugins as they can + * prevent transmits based on external signals. + */ + EMBER_PHY_TX_BLOCKED = 0x8E, + +/** + * @brief The expected ACK was received after the last transmission. + */ + EMBER_PHY_ACK_RECEIVED = 0x8F, + +//@} + +/** + * @name Return Codes Passed to emberStackStatusHandler() + * See also ::emberStackStatusHandler = ,. + */ +//@{ + +/** + * @brief The stack software has completed initialization and is ready + * to send and receive packets over the air. + */ + EMBER_NETWORK_UP = 0x90, + +/** + * @brief The network is not operating. + */ + EMBER_NETWORK_DOWN = 0x91, + +/** + * @brief An attempt to join a network failed. + */ + EMBER_JOIN_FAILED = 0x94, + +/** + * @brief After moving, a mobile node's attempt to re-establish contact + * with the network failed. + */ + EMBER_MOVE_FAILED = 0x96, + +/** + * @brief An attempt to join as a router failed due to a Zigbee + * versus Zigbee Pro incompatibility. Zigbee devices joining Zigbee Pro networks + * (or vice versa) must join as End Devices, not Routers. + */ + EMBER_CANNOT_JOIN_AS_ROUTER = 0x98, + +/** @brief The local node ID has changed. The application can get the new + * node ID by calling ::emberGetNodeId(). + */ + EMBER_NODE_ID_CHANGED = 0x99, + +/** @brief The local PAN ID has changed. The application can get the new PAN + * ID by calling ::emberGetPanId(). + */ + EMBER_PAN_ID_CHANGED = 0x9A, + +/** @brief The channel has changed. + */ + EMBER_CHANNEL_CHANGED = 0x9B, + +/** @brief An attempt to join or rejoin the network failed because + * no router beacons could be heard by the joining node. + */ + EMBER_NO_BEACONS = 0xAB, + +/** @brief An attempt was made to join a Secured Network using a pre-configured + * key, but the Trust Center sent back a Network Key in-the-clear when + * an encrypted Network Key was required. (::EMBER_REQUIRE_ENCRYPTED_KEY). + */ + EMBER_RECEIVED_KEY_IN_THE_CLEAR = 0xAC, + +/** @brief An attempt was made to join a Secured Network, but the device did + * not receive a Network Key. + */ + EMBER_NO_NETWORK_KEY_RECEIVED = 0xAD, + +/** @brief After a device joined a Secured Network, a Link Key was requested + * (::EMBER_GET_LINK_KEY_WHEN_JOINING) but no response was ever received. + */ + EMBER_NO_LINK_KEY_RECEIVED = 0xAE, + +/** @brief An attempt was made to join a Secured Network without a + * pre-configured key, but the Trust Center sent encrypted data using a + * pre-configured key. + */ + EMBER_PRECONFIGURED_KEY_REQUIRED = 0xAF, + +//@} + +/** + * @name Security Errors + */ +/** + * @brief The passed key data is not valid. A key of all zeros or + * all F's are reserved values and cannot be used. + */ + EMBER_KEY_INVALID = 0xB2, + +/** + * @brief The chosen security level (the value of ::EMBER_SECURITY_LEVEL) + * is not supported by the stack. + */ + EMBER_INVALID_SECURITY_LEVEL = 0x95, + +/** + * @brief An error occurred when trying to encrypt at the APS Level. + * + * In order to APS encrypt an outgoing packet, the sender + * needs to know the EUI64 of the destination. This error occurs because + * the EUI64 of the destination can't be determined from + * the short address (no entry in the neighbor, child, binding + * or address tables). + * + * Everytime this error code is seen, note that the stack initiates an + * IEEE address discovery request behind the scenes. Responses + * to the request are stored in the trust center cache portion of the + * address table. Note that you need at least 1 entry allocated for + * TC cache in the address table plugin. Depending on the available rows in + * the table, newly discovered addresses may replace old ones. The address + * table plugin is enabled by default on the host. If you are using an SoC + * platform, please be sure to add the address table plugin. + * + * When customers choose to send APS messages by using short addresses, + * they should incorporate a retry mechanism and try again, no sooner than + * 2 seconds later, to resend the APS message. If the app always + * receives 0xBE (EMBER_IEEE_ADDR_DISCOVERY_IN_PROGRESS) after + * multiple retries, that might indicate that: + * a) destination node is not on the network + * b) there are problems with the health of the network + * c) there may not be any space set asidein the address table for + * the newly discovered address - this can be rectified by reserving + * more entries for the trust center cache in the address table plugin + */ + EMBER_IEEE_ADDRESS_DISCOVERY_IN_PROGRESS = 0xBE, +/** + * @brief An error occurred when trying to encrypt at the APS Level. + * + * This error occurs either because the long address of the recipient can't be + * determined from the short address (no entry in the binding table) + * or there is no link key entry in the table associated with the destination, + * or there was a failure to load the correct key into the encryption core. + */ + EMBER_APS_ENCRYPTION_ERROR = 0xA6, + +/** @brief There was an attempt to form or join a network with security + * without calling ::emberSetInitialSecurityState() first. + */ + EMBER_SECURITY_STATE_NOT_SET = 0xA8, + +/** @brief There was an attempt to set an entry in the key table using + * an invalid long address. Invalid addresses include: + * - The local device's IEEE address + * - Trust Center's IEEE address + * - An existing table entry's IEEE address + * - An address consisting of all zeros or all F's + */ + EMBER_KEY_TABLE_INVALID_ADDRESS = 0xB3, + +/** @brief There was an attempt to set a security configuration that + * is not valid given the other security settings. + */ + EMBER_SECURITY_CONFIGURATION_INVALID = 0xB7, + +/** @brief There was an attempt to broadcast a key switch too quickly after + * broadcasting the next network key. The Trust Center must wait at + * least a period equal to the broadcast timeout so that all routers + * have a chance to receive the broadcast of the new network key. + */ + EMBER_TOO_SOON_FOR_SWITCH_KEY = 0xB8, + +/** @brief The received signature corresponding to the message that was passed + to the CBKE Library failed verification and is not valid. + */ + EMBER_SIGNATURE_VERIFY_FAILURE = 0xB9, + +/** @brief The message could not be sent because the link key corresponding + to the destination is not authorized for use in APS data messages. + APS Commands (sent by the stack) are allowed. To use it for encryption + of APS data messages it must be authorized using a key agreement protocol + (such as CBKE). + */ + EMBER_KEY_NOT_AUTHORIZED = 0xBB, + +/** @brief The security data provided was not valid, or an + * integrity check failed. + */ + EMBER_SECURITY_DATA_INVALID = 0xBD, + +//@} + +/** + * @name Miscellaneous Network Errors + */ +//@{ + +/** + * @brief The node has not joined a network. + */ + EMBER_NOT_JOINED = 0x93, + +/** + * @brief A message cannot be sent because the network is currently + * overloaded. + */ + EMBER_NETWORK_BUSY = 0xA1, + +/** + * @brief The application tried to send a message using an + * endpoint that it has not defined. + */ + EMBER_INVALID_ENDPOINT = 0xA3, + +/** + * @brief The application tried to use a binding that has been remotely + * modified and the change has not yet been reported to the application. + */ + EMBER_BINDING_HAS_CHANGED = 0xA4, + +/** + * @brief An attempt to generate random bytes failed because of + * insufficient random data from the radio. + */ + EMBER_INSUFFICIENT_RANDOM_DATA = 0xA5, + +/** A Zigbee route error command frame was received indicating + * that a source routed message from this node failed en route. + */ + EMBER_SOURCE_ROUTE_FAILURE = 0xA9, + +/** A Zigbee route error command frame was received indicating + * that a message sent to this node along a many-to-one route + * failed en route. The route error frame was delivered by + * an ad-hoc search for a functioning route. + */ + EMBER_MANY_TO_ONE_ROUTE_FAILURE = 0xAA, + +//@} + +/** + * @name Miscellaneous Utility Errors + */ +//@{ + +/** + * @brief A critical and fatal error indicating that the version of the + * stack trying to run does not match with the chip it's running on. The + * software (stack) on the chip must be replaced with software + * compatible with the chip. + */ + EMBER_STACK_AND_HARDWARE_MISMATCH = 0xB0, + +/** + * @brief An index was passed into the function that was larger + * than the valid range. + */ + EMBER_INDEX_OUT_OF_RANGE = 0xB1, + +/** + * @brief There are no empty entries left in the table. + */ + EMBER_TABLE_FULL = 0xB4, + +/** + * @brief The requested table entry has been erased and contains + * no valid data. + */ + EMBER_TABLE_ENTRY_ERASED = 0xB6, + +/** + * @brief The requested function cannot be executed because + * the library that contains the necessary functionality is not present. + */ + EMBER_LIBRARY_NOT_PRESENT = 0xB5, + +/** + * @brief The stack accepted the command and is currently processing + * the request. The results will be returned via an appropriate handler. + */ + EMBER_OPERATION_IN_PROGRESS = 0xBA, + +/** + * @brief The EUI of the Trust center has changed due to a successful rejoin. + * The device may need to perform other authentication to verify the new TC + * is authorized to take over. + */ + EMBER_TRUST_CENTER_EUI_HAS_CHANGED = 0xBC, + +//@} + +/** + * @name NVM3 Token Errors + */ +//@{ + +/** + * @brief NVM3 is telling the application that the initialization was aborted + * as no valid NVM3 page was found. + */ + EMBER_NVM3_TOKEN_NO_VALID_PAGES = 0xC0, + +/** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 instance was already opened with other parameters. + */ + EMBER_NVM3_ERR_OPENED_WITH_OTHER_PARAMETERS = 0xC1, + +/** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 instance is not aligned properly in memory. + */ + EMBER_NVM3_ERR_ALIGNMENT_INVALID = 0xC2, + +/** + * @brief NVM3 is telling the application that the initialization was aborted + * as the size of the NVM3 instance is too small. + */ + EMBER_NVM3_ERR_SIZE_TOO_SMALL = 0xC3, + +/** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 page size is not supported. + */ + EMBER_NVM3_ERR_PAGE_SIZE_NOT_SUPPORTED = 0xC4, + +/** + * @brief NVM3 is telling the application that there was an error initializing + * some of the tokens. + */ + EMBER_NVM3_ERR_TOKEN_INIT = 0xC5, + +/** + * @brief NVM3 is telling the application there has been an error when + * attempting to upgrade SimEE tokens. + */ + EMBER_NVM3_ERR_UPGRADE = 0xC6, + +/** + * @brief NVM3 is telling the application that there has been an unknown + * error. + */ + EMBER_NVM3_ERR_UNKNOWN = 0xC7, + +//@} + +/** + * @name Application Errors + * These error codes are available for application use. + */ +//@{ + +/** + * @brief This error is reserved for customer application use. + * This will never be returned from any portion of the network stack or HAL. + */ + EMBER_APPLICATION_ERROR_0 = 0xF0, + EMBER_APPLICATION_ERROR_1 = 0xF1, + EMBER_APPLICATION_ERROR_2 = 0xF2, + EMBER_APPLICATION_ERROR_3 = 0xF3, + EMBER_APPLICATION_ERROR_4 = 0xF4, + EMBER_APPLICATION_ERROR_5 = 0xF5, + EMBER_APPLICATION_ERROR_6 = 0xF6, + EMBER_APPLICATION_ERROR_7 = 0xF7, + EMBER_APPLICATION_ERROR_8 = 0xF8, + EMBER_APPLICATION_ERROR_9 = 0xF9, + EMBER_APPLICATION_ERROR_10 = 0xFA, + EMBER_APPLICATION_ERROR_11 = 0xFB, + EMBER_APPLICATION_ERROR_12 = 0xFC, + EMBER_APPLICATION_ERROR_13 = 0xFD, + EMBER_APPLICATION_ERROR_14 = 0xFE, + EMBER_APPLICATION_ERROR_15 = 0xFF, +}; + +/** @brief The control structure for events. + * + * This structure should not be accessed directly. + * It holds the event status (one of the @e EMBER_EVENT_ values) + * and the time left before the event fires. + */ +typedef struct { + /** The event's status, either inactive or the units for timeToExecute. */ + EmberEventUnits status; + /** The ID of the task this event belongs to. */ + EmberTaskId taskid; + /** Indicates how long before the event fires. + * Units are milliseconds. + */ + uint32_t timeToExecute; +} EmberEventControl; + + +/** + * @name ZigBee Broadcast Addresses + *@{ + * ZigBee specifies three different broadcast addresses that + * reach different collections of nodes. Broadcasts are normally sent only + * to routers. Broadcasts can also be forwarded to end devices, either + * all of them or only those that do not sleep. Broadcasting to end + * devices is both significantly more resource-intensive and significantly + * less reliable than broadcasting to routers. + */ + +/** Broadcast to all routers. */ +#define EMBER_BROADCAST_ADDRESS 0xFFFC + +/** + * @description Useful macro for avoiding compiler warnings related to unused + * function arguments or unused variables. + */ +#define UNUSED_VAR(x) (void )(x) + + +/** + * @brief The maximum 802.15.4 channel number is 26. + */ +#define EMBER_MAX_802_15_4_CHANNEL_NUMBER 26 + +/** + * @brief The minimum 2.4GHz 802.15.4 channel number is 11. + */ +#define EMBER_MIN_802_15_4_CHANNEL_NUMBER 1 +/** + * @brief Defines the possible join states for a node. + */ +#ifdef DOXYGEN_SHOULD_SKIP_THIS +enum EmberNetworkStatus +#else +typedef uint8_t EmberNetworkStatus; +enum +#endif +{ + /** The node is not associated with a network in any way. */ + EMBER_NO_NETWORK, + /** The node is currently attempting to join a network. */ + EMBER_JOINING_NETWORK, + /** The node is joined to a network. */ + EMBER_JOINED_NETWORK, + /** The node is an end device joined to a network but its parent + is not responding. */ + EMBER_JOINED_NETWORK_NO_PARENT, + /** The node is in the process of leaving its current network. */ + EMBER_LEAVING_NETWORK +}; + +/** + * @brief The maximum SubGhz channel number on pages 28, 30, 31 is 26. + */ +#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31 26 + + +/** + * @brief The maximum SubGhz channel number on page 29 is 8. + */ +#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29 8 + + +/** + * @brief The broadcast endpoint, as defined in the ZigBee spec. + */ +#define EMBER_BROADCAST_ENDPOINT 0xFF + +/** + * @brief Friendly convenience macro pointing to the C Stdlib functions. + */ + #define MEMSET(d, v, l) memset(d, v, l) + #define MEMCOPY(d, s, l) memcpy(d, s, l) + #define MEMMOVE(d, s, l) memmove(d, s, l) + #define MEMPGMCOPY(d, s, l) memcpy(d, s, l) + #define MEMCOMPARE(s0, s1, l) memcmp(s0, s1, l) + #define MEMPGMCOMPARE(s0, s1, l) memcmp(s0, s1, l) + +/** + * @brief Useful to reference a single bit of a byte. + */ +#define BIT(x) (1U << (x)) // Unsigned avoids compiler warnings re BIT(15) + +/** + * @brief Returns the low byte of the 16-bit value \c n as an \c uint8_t. + */ +#define LOW_BYTE(n) ((uint8_t)((n) & 0xFF)) + +/** + * @brief Returns the high byte of the 16-bit value \c n as an \c uint8_t. + */ +#define HIGH_BYTE(n) ((uint8_t)(LOW_BYTE((n) >> 8))) +/** + * @brief Returns the low byte of the 32-bit value \c n as an \c uint8_t. + */ +#define BYTE_0(n) ((uint8_t)((n) & 0xFF)) + +/** + * @brief Returns the second byte of the 32-bit value \c n as an \c uint8_t. + */ +#define BYTE_1(n) BYTE_0((n) >> 8) + +/** + * @brief Returns the third byte of the 32-bit value \c n as an \c uint8_t. + */ +#define BYTE_2(n) BYTE_0((n) >> 16) + +/** + * @brief Returns the high byte of the 32-bit value \c n as an \c uint8_t. + */ +#define BYTE_3(n) BYTE_0((n) >> 24) + +/** + * @brief Returns the fifth byte of the 64-bit value \c n as an \c uint8_t. + */ +#define BYTE_4(n) BYTE_0((n) >> 32) + +/** + * @brief Returns the sixth byte of the 64-bit value \c n as an \c uint8_t. + */ +#define BYTE_5(n) BYTE_0((n) >> 40) + +/** + * @brief Returns the seventh byte of the 64-bit value \c n as an \c uint8_t. + */ +#define BYTE_6(n) BYTE_0((n) >> 48) + +/** + * @brief Returns the high byte of the 64-bit value \c n as an \c uint8_t. + */ +#define BYTE_7(n) BYTE_0((n) >> 56) + +/** + * @brief The kind of arguments the main function takes + */ +#define MAIN_FUNCTION_PARAMETERS void +#define MAIN_FUNCTION_ARGUMENTS diff --git a/examples/wifi-echo/server/esp32/main/util.c b/examples/wifi-echo/server/esp32/main/util.c new file mode 100644 index 00000000000000..e6af4298a7f525 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/util.c @@ -0,0 +1,1361 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief This file contains all of the common ZCL command and attribute handling + * code for Ember's ZCL implementation + ******************************************************************************* + ******************************************************************************/ + +#include "../include/af.h" +#include "af-main.h" +#include "common.h" +#include "../plugin/time-server/time-server.h" +#include "app/framework/util/af-event.h" +#include "app/framework/util/time-util.h" +#include "znet-bookkeeping.h" +#include "hal/micro/crc.h" + +//------------------------------------------------------------------------------ +// Forward Declarations + +//------------------------------------------------------------------------------ +// Globals + +// Storage and functions for turning on and off devices +bool afDeviceEnabled[MAX_ENDPOINT_COUNT]; + +#ifdef EMBER_AF_ENABLE_STATISTICS +// a variable containing the number of messages send from the utilities +// since emberAfInit was called. +uint32_t afNumPktsSent; +#endif + +const EmberAfClusterName zclClusterNames[] = { + CLUSTER_IDS_TO_NAMES // defined in print-cluster.h + { ZCL_NULL_CLUSTER_ID, EMBER_AF_NULL_MANUFACTURER_CODE, NULL }, // terminator +}; + +static const EmberAfClusterCommand staticCmd; +EmberAfClusterCommand curCmd; +// A pointer to the current command being processed +// This struct is allocated on the stack inside +// emberAfProcessMessage. The pointer below is set +// to NULL when the function exits. +EmberAfClusterCommand *emAfCurrentCommand; + +// variable used for toggling Aps Link security. Set by the CLI +uint8_t emAfTestApsSecurityOverride = APS_TEST_SECURITY_DEFAULT; + +// DEPRECATED. +uint8_t emberAfIncomingZclSequenceNumber = 0xFF; + +static bool afNoSecurityForDefaultResponse = false; + +// Sequence used for outgoing messages if they are +// not responses. +uint8_t emberAfSequenceNumber = 0xFF; + +// A bool value so we know when the device is performing +// key establishment. +bool emAfDeviceIsPerformingKeyEstablishment = false; + +static uint8_t /*enum EmberAfRetryOverride*/ emberAfApsRetryOverride = EMBER_AF_RETRY_OVERRIDE_NONE; +static uint8_t /*enum EmberAfDisableDefaultResponse*/ emAfDisableDefaultResponse = EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE; +static uint8_t /*enum EmberAfDisableDefaultResponse*/ emAfSavedDisableDefaultResponseVale = EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE; + +// Holds the response type +uint8_t emberAfResponseType = ZCL_UTIL_RESP_NORMAL; + +static EmberAfInterpanHeader interpanResponseHeader; + +static const uint8_t emberAfAnalogDiscreteThresholds[] = { + 0x07, EMBER_AF_DATA_TYPE_NONE, + 0x1F, EMBER_AF_DATA_TYPE_DISCRETE, + 0x2F, EMBER_AF_DATA_TYPE_ANALOG, + 0x37, EMBER_AF_DATA_TYPE_DISCRETE, + 0x3F, EMBER_AF_DATA_TYPE_ANALOG, + 0x57, EMBER_AF_DATA_TYPE_DISCRETE, + 0xDF, EMBER_AF_DATA_TYPE_NONE, + 0xE7, EMBER_AF_DATA_TYPE_ANALOG, + 0xFF, EMBER_AF_DATA_TYPE_NONE +}; + +uint8_t emAfExtendedPanId[EXTENDED_PAN_ID_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, }; + +#ifdef EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_DECLARATIONS +EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_DECLARATIONS +#endif +#ifdef EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_DECLARATIONS +EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_DECLARATIONS +#endif + +//------------------------------------------------------------------------------ + +// Device enabled/disabled functions +bool emberAfIsDeviceEnabled(uint8_t endpoint) +{ + uint8_t index; +#ifdef ZCL_USING_BASIC_CLUSTER_DEVICE_ENABLED_ATTRIBUTE + bool deviceEnabled; + if (emberAfReadServerAttribute(endpoint, + ZCL_BASIC_CLUSTER_ID, + ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, + (uint8_t *)&deviceEnabled, + sizeof(deviceEnabled)) + == EMBER_ZCL_STATUS_SUCCESS) { + return deviceEnabled; + } +#endif + index = emberAfIndexFromEndpoint(endpoint); + if (index != 0xFF && index < sizeof(afDeviceEnabled)) { + return afDeviceEnabled[index]; + } + return false; +} + +void emberAfSetDeviceEnabled(uint8_t endpoint, bool enabled) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index != 0xFF && index < sizeof(afDeviceEnabled)) { + afDeviceEnabled[index] = enabled; + } +#ifdef ZCL_USING_BASIC_CLUSTER_DEVICE_ENABLED_ATTRIBUTE + emberAfWriteServerAttribute(endpoint, + ZCL_BASIC_CLUSTER_ID, + ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, + (uint8_t *)&enabled, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); +#endif +} + +// Is the device identifying? +bool emberAfIsDeviceIdentifying(uint8_t endpoint) +{ +#ifdef ZCL_USING_IDENTIFY_CLUSTER_SERVER + uint16_t identifyTime; + EmberAfStatus status = emberAfReadServerAttribute(endpoint, + ZCL_IDENTIFY_CLUSTER_ID, + ZCL_IDENTIFY_TIME_ATTRIBUTE_ID, + (uint8_t *)&identifyTime, + sizeof(identifyTime)); + return (status == EMBER_ZCL_STATUS_SUCCESS && 0 < identifyTime); +#else + return false; +#endif +} + +// Calculates difference. See EmberAfDifferenceType for the maximum data size +// that this function will support. +EmberAfDifferenceType emberAfGetDifference(uint8_t *pData, + EmberAfDifferenceType value, + uint8_t dataSize) +{ + EmberAfDifferenceType value2 = 0, diff; + uint8_t i; + + // only support data types up to 8 bytes + if (dataSize > sizeof(EmberAfDifferenceType)) { + return 0; + } + + // get the value + for (i = 0; i < dataSize; i++) { + value2 = value2 << 8; +#if (BIGENDIAN_CPU) + value2 += pData[i]; +#else //BIGENDIAN + value2 += pData[dataSize - i - 1]; +#endif //BIGENDIAN + } + + if (value > value2) { + diff = value - value2; + } else { + diff = value2 - value; + } + + return diff; +} + +// -------------------------------------------------- + +static void prepareForResponse(const EmberAfClusterCommand *cmd) +{ + emberAfResponseApsFrame.profileId = cmd->apsFrame->profileId; + emberAfResponseApsFrame.clusterId = cmd->apsFrame->clusterId; + emberAfResponseApsFrame.sourceEndpoint = cmd->apsFrame->destinationEndpoint; + emberAfResponseApsFrame.destinationEndpoint = cmd->apsFrame->sourceEndpoint; + + // Use the default APS options for the response, but also use encryption and + // retries if the incoming message used them. The rationale is that the + // sender of the request cares about some aspects of the delivery, so we as + // the receiver should make equal effort for the response. + emberAfResponseApsFrame.options = EMBER_AF_DEFAULT_APS_OPTIONS; + if ((cmd->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } + if ((cmd->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; + } + + if (cmd->interPanHeader == NULL) { + emberAfResponseDestination = cmd->source; + emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; + } else { + emberAfResponseType |= ZCL_UTIL_RESP_INTERPAN; + MEMMOVE(&interpanResponseHeader, + cmd->interPanHeader, + sizeof(EmberAfInterpanHeader)); + // Always send responses as unicast + interpanResponseHeader.messageType = EMBER_AF_INTER_PAN_UNICAST; + } +} + +// **************************************** +// Initialize Clusters +// **************************************** +void emberAfInit(void) +{ + uint8_t i; +#ifdef EMBER_AF_ENABLE_STATISTICS + afNumPktsSent = 0; +#endif + + for (i = 0; i < EMBER_SUPPORTED_NETWORKS; i++) { + emberAfPushNetworkIndex(i); + emberAfInitializeAttributes(EMBER_BROADCAST_ENDPOINT); + emberAfPopNetworkIndex(); + } + + MEMSET(afDeviceEnabled, true, emberAfEndpointCount()); + + // Set up client API buffer. + emberAfSetExternalBuffer(appResponseData, + EMBER_AF_RESPONSE_BUFFER_LEN, + &appResponseLength, + &emberAfResponseApsFrame); + + // initialize event management system + emAfInitEvents(); + +#ifdef EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS + EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS +#endif + + emAfCallInits(); +} + +void emberAfTick(void) +{ + // Call the AFV2-specific per-endpoint callbacks + // Anything that defines callbacks as void *TickCallback(void) is called in + // emAfInit(), which is a generated file +#ifdef EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_CALLS + EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_CALLS +#endif +} + +// **************************************** +// This function is called by the application when the stack goes down, +// such as after a leave network. This allows zcl utils to clear state +// that should not be kept when changing networks +// **************************************** +void emberAfStackDown(void) +{ + // (Case 14696) Clearing the report table is only necessary if the stack is + // going down for good; if we're rejoining, leave the table intact since we'll + // be right back, hopefully. + // (Issue 77101) Also don't clear the table if the stack has gone down as a + // a result of losing its parent or some other transient state where a future + // rejoin is expected to get us back online. + if (emberStackIsPerformingRejoin() == false + && emberNetworkState() == EMBER_NO_NETWORK) { + // the report table should be cleared when the stack comes down. + // going to a new network means new report devices should be discovered. + // if the table isnt cleared the device keeps trying to send messages. + emberAfClearReportTableCallback(); + } + + emberAfRegistrationAbortCallback(); + emberAfTrustCenterKeepaliveAbortCallback(); +} + +// **************************************** +// Print out information about each cluster +// **************************************** + +uint16_t emberAfFindClusterNameIndexWithMfgCode(uint16_t cluster, uint16_t mfgCode) +{ + uint16_t index = 0; + while (zclClusterNames[index].id != ZCL_NULL_CLUSTER_ID) { + if (zclClusterNames[index].id == cluster + // This check sees if its a standard cluster, in which mfgCode is ignored + // due to the name being well defined. + // If it is manufacturer specific, then we try to check to see if we + // know the name of the cluster within the list. + // If the mfgCode we are given is null, then we just ignore it for backward + // compatibility reasons + && (cluster < 0xFC00 + || zclClusterNames[index].mfgCode == mfgCode + || mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE)) { + return index; + } + index++; + } + return 0xFFFF; +} + +uint16_t emberAfFindClusterNameIndex(uint16_t cluster) +{ + return emberAfFindClusterNameIndexWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// This function parses into the cluster name table, and tries to find +// the index in the table that has the two keys: cluster + mfgcode. +void emberAfDecodeAndPrintClusterWithMfgCode(uint16_t cluster, uint16_t mfgCode) +{ + uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); + if (index == 0xFFFF) { + emberAfPrint(emberAfPrintActiveArea, + "(Unknown clus. [0x%2x])", + cluster); + } else { + emberAfPrint(emberAfPrintActiveArea, + "(%p)", + zclClusterNames[index].name); + } +} + +void emberAfDecodeAndPrintCluster(uint16_t cluster) +{ + emberAfDecodeAndPrintClusterWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); +} + +// This function makes the assumption that +// emberAfCurrentCommand will either be NULL +// when invalid, or will have a valid mfgCode +// when called. +// If it is invalid, we just return the +// EMBER_AF_NULL_MANUFACTURER_CODE, which we tend to use +// for references to the standard library. +uint16_t emberAfGetMfgCodeFromCurrentCommand(void) +{ + if (emberAfCurrentCommand() != NULL) { + return emberAfCurrentCommand()->mfgCode; + } else { + return EMBER_AF_NULL_MANUFACTURER_CODE; + } +} + +static void printIncomingZclMessage(const EmberAfClusterCommand *cmd) +{ +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) + if (emberAfPrintReceivedMessages) { + emberAfAppPrint("\r\nT%4x:", emberAfGetCurrentTime()); + emberAfAppPrint("RX len %d, ep %x, clus 0x%2x ", + cmd->bufLen, + cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->clusterId); + emberAfAppDebugExec(emberAfDecodeAndPrintClusterWithMfgCode(cmd->apsFrame->clusterId, cmd->mfgCode)); + if (cmd->mfgSpecific) { + emberAfAppPrint(" mfgId %2x", cmd->mfgCode); + } + emberAfAppPrint(" FC %x seq %x cmd %x payload[", + cmd->buffer[0], // frame control + cmd->seqNum, + cmd->commandId); + emberAfAppFlush(); + emberAfAppPrintBuffer(cmd->buffer + cmd->payloadStartIndex, // message + cmd->bufLen - cmd->payloadStartIndex, // length + true); // spaces? + emberAfAppFlush(); + emberAfAppPrintln("]"); + } +#endif +} + +static bool dispatchZclMessage(EmberAfClusterCommand *cmd) +{ + uint8_t index = emberAfIndexFromEndpoint(cmd->apsFrame->destinationEndpoint); + if (index == 0xFF) { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", + cmd->apsFrame->clusterId, + cmd->commandId); + emberAfDebugPrint(" due to invalid endpoint: "); + emberAfDebugPrintln("0x%x", cmd->apsFrame->destinationEndpoint); + return false; + } else if (emberAfNetworkIndexFromEndpointIndex(index) != cmd->networkIndex) { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", + cmd->apsFrame->clusterId, + cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", + cmd->apsFrame->destinationEndpoint, + "network"); + emberAfDebugPrintln("%d", cmd->networkIndex); + return false; + } else if (emberAfProfileIdFromIndex(index) != cmd->apsFrame->profileId + && (cmd->apsFrame->profileId != EMBER_WILDCARD_PROFILE_ID + || (EMBER_MAXIMUM_STANDARD_PROFILE_ID + < emberAfProfileIdFromIndex(index)))) { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", + cmd->apsFrame->clusterId, + cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", + cmd->apsFrame->destinationEndpoint, + "profile"); + emberAfDebugPrintln("0x%2x", cmd->apsFrame->profileId); + return false; + } else if ((cmd->type == EMBER_INCOMING_MULTICAST + || cmd->type == EMBER_INCOMING_MULTICAST_LOOPBACK) + && !emberAfGroupsClusterEndpointInGroupCallback(cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->groupId)) { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", + cmd->apsFrame->clusterId, + cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", + cmd->apsFrame->destinationEndpoint, + "group"); + emberAfDebugPrintln("0x%2x", cmd->apsFrame->groupId); + return false; + } else { + return (cmd->clusterSpecific + ? emAfProcessClusterSpecificCommand(cmd) + : emAfProcessGlobalCommand(cmd)); + } +} + +bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, + EmberIncomingMessageType type, + uint8_t* message, + uint16_t messageLength, + EmberNodeId source, + InterPanHeader* interPanHeader, + EmberAfClusterCommand* returnCmd) +{ + uint8_t minLength = (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK + ? EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD + : EMBER_AF_ZCL_OVERHEAD); + + if (messageLength < minLength) { + emberAfAppPrintln("%pRX pkt too short: %d < %d", "ERROR: ", messageLength, minLength); + return false; + } + + // Populate the cluster command struct for processing. + returnCmd->apsFrame = apsFrame; + returnCmd->type = type; + returnCmd->source = source; + returnCmd->buffer = message; + returnCmd->bufLen = messageLength; + returnCmd->clusterSpecific = (message[0] & ZCL_CLUSTER_SPECIFIC_COMMAND); + returnCmd->mfgSpecific = (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK); + returnCmd->direction = ((message[0] & ZCL_FRAME_CONTROL_DIRECTION_MASK) + ? ZCL_DIRECTION_SERVER_TO_CLIENT + : ZCL_DIRECTION_CLIENT_TO_SERVER); + returnCmd->payloadStartIndex = 1; + if (returnCmd->mfgSpecific) { + returnCmd->mfgCode = emberAfGetInt16u(message, returnCmd->payloadStartIndex, messageLength); + returnCmd->payloadStartIndex += 2; + } else { + returnCmd->mfgCode = EMBER_AF_NULL_MANUFACTURER_CODE; + } + returnCmd->seqNum = message[returnCmd->payloadStartIndex++]; + returnCmd->commandId = message[returnCmd->payloadStartIndex++]; + if ( returnCmd->payloadStartIndex > returnCmd->bufLen ) { + emberAfAppPrintln("%pRX pkt malformed: %d < %d", "ERROR: ", returnCmd->bufLen, returnCmd->payloadStartIndex); + return false; + } + returnCmd->interPanHeader = interPanHeader; + returnCmd->networkIndex = emberGetCurrentNetwork(); + return true; +} + +// a single call to process global and cluster-specific messages and callbacks. +bool emberAfProcessMessage(EmberApsFrame *apsFrame, + EmberIncomingMessageType type, + uint8_t *message, + uint16_t msgLen, + EmberNodeId source, + InterPanHeader *interPanHeader) +{ + EmberStatus sendStatus; + bool msgHandled = false; + //reset/reinitialize curCmd + curCmd = staticCmd; + if (!emberAfProcessMessageIntoZclCmd(apsFrame, + type, + message, + msgLen, + source, + interPanHeader, + &curCmd)) { + goto kickout; + } + + emAfCurrentCommand = &curCmd; + + // All of these should be covered by the EmberAfClusterCommand but are + // still here until all the code is moved over to use the cmd. -WEH + emberAfIncomingZclSequenceNumber = curCmd.seqNum; + + printIncomingZclMessage(&curCmd); + prepareForResponse(&curCmd); + + if (emAfPreCommandReceived(&curCmd)) { + msgHandled = true; + goto kickout; + } + + if (interPanHeader == NULL) { + bool broadcast = (type == EMBER_INCOMING_BROADCAST + || type == EMBER_INCOMING_BROADCAST_LOOPBACK + || type == EMBER_INCOMING_MULTICAST + || type == EMBER_INCOMING_MULTICAST_LOOPBACK); + + // if the cluster for the incoming message requires security and + // doesnt have it return default response STATUS_FAILURE + if (emberAfDetermineIfLinkSecurityIsRequired(curCmd.commandId, + true, // incoming + broadcast, + curCmd.apsFrame->profileId, + curCmd.apsFrame->clusterId, + curCmd.source) + && (!(curCmd.apsFrame->options & EMBER_APS_OPTION_ENCRYPTION))) { + emberAfDebugPrintln("Drop clus %2x due to no aps security", + curCmd.apsFrame->clusterId); + afNoSecurityForDefaultResponse = true; + sendStatus = emberAfSendDefaultResponse(&curCmd, EMBER_ZCL_STATUS_NOT_AUTHORIZED); + if (EMBER_SUCCESS != sendStatus) { + emberAfDebugPrintln("Util: failed to send %s response: 0x%x", + "default", + sendStatus); + } + afNoSecurityForDefaultResponse = false; + + // Mark the message as processed. It failed security processing, so no + // other parts of the code should act upon it. + msgHandled = true; + goto kickout; + } + } else if (!(interPanHeader->options + & EMBER_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS)) { + // For safety, dump all interpan messages that don't have a long + // source in the MAC layer. In theory they should not get past + // the MAC filters but this is insures they will not get processed. + goto kickout; + } else { + // MISRA requires ..else if.. to have terminating else. + } + + if (curCmd.apsFrame->destinationEndpoint == EMBER_BROADCAST_ENDPOINT) { + uint8_t i; + for (i = 0; i < emberAfEndpointCount(); i++) { + uint8_t endpoint = emberAfEndpointFromIndex(i); + if (!emberAfEndpointIndexIsEnabled(i) + || !emberAfContainsClusterWithMfgCode(endpoint, curCmd.apsFrame->clusterId, curCmd.mfgCode)) { + continue; + } + // Since the APS frame is cleared after each sending, + // we must reinitialize it. It is cleared to prevent + // data from leaking out and being sent inadvertently. + prepareForResponse(&curCmd); + + // Change the destination endpoint of the incoming command and the source + // source endpoint of the response so they both reflect the endpoint the + // message is actually being passed to in this iteration of the loop. + curCmd.apsFrame->destinationEndpoint = endpoint; + emberAfResponseApsFrame.sourceEndpoint = endpoint; + if (dispatchZclMessage(&curCmd)) { + msgHandled = true; + } + } + } else { + msgHandled = dispatchZclMessage(&curCmd); + } + + kickout: + emberAfClearResponseData(); + MEMSET(&interpanResponseHeader, + 0, + sizeof(EmberAfInterpanHeader)); + emAfCurrentCommand = NULL; + return msgHandled; +} + +uint8_t emberAfNextSequence(void) +{ + return ((++emberAfSequenceNumber) & EMBER_AF_ZCL_SEQUENCE_MASK); +} + +uint8_t emberAfGetLastSequenceNumber(void) +{ + return (emberAfSequenceNumber & EMBER_AF_ZCL_SEQUENCE_MASK); +} + +// the caller to the library can set a flag to say do not respond to the +// next ZCL message passed in to the library. Passing true means disable +// the reply for the next ZCL message. Setting to false re-enables the +// reply (in the case where the app disables it and then doesnt send a +// message that gets parsed). +void emberAfSetNoReplyForNextMessage(bool set) +{ + if (set) { + emberAfResponseType |= ZCL_UTIL_RESP_NONE; + } else { + emberAfResponseType &= ~ZCL_UTIL_RESP_NONE; + } +} + +void emberAfSetRetryOverride(EmberAfRetryOverride value) +{ + emberAfApsRetryOverride = value; +} + +EmberAfRetryOverride emberAfGetRetryOverride(void) +{ + return (EmberAfRetryOverride) emberAfApsRetryOverride; +} + +void emAfApplyRetryOverride(EmberApsOption *options) +{ + if (options == NULL) { + return; + } else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_SET) { + *options |= EMBER_APS_OPTION_RETRY; + } else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_UNSET) { + *options &= ~EMBER_APS_OPTION_RETRY; + } else { + // MISRA requires ..else if.. to have terminating else. + } +} + +void emberAfSetDisableDefaultResponse(EmberAfDisableDefaultResponse value) +{ + emAfDisableDefaultResponse = value; + if (value != EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) { + emAfSavedDisableDefaultResponseVale = value; + } +} + +EmberAfDisableDefaultResponse emberAfGetDisableDefaultResponse(void) +{ + return (EmberAfDisableDefaultResponse) emAfDisableDefaultResponse; +} + +void emAfApplyDisableDefaultResponse(uint8_t *frame_control) +{ + if (frame_control == NULL) { + return; + } else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) { + emAfDisableDefaultResponse = emAfSavedDisableDefaultResponseVale; + *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; + } else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT) { + *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; + } else { + // MISRA requires ..else if.. to have terminating else. + } +} + +EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) +{ + EmberStatus status; + uint8_t label; + + // If the no-response flag is set, don't send anything. + if ((emberAfResponseType & ZCL_UTIL_RESP_NONE) != 0U) { + emberAfDebugPrintln("ZCL Util: no response at user request"); + return EMBER_SUCCESS; + } + + // Make sure we are respecting the request APS options + // there are seemingly some calls to emberAfSendResponse + // that occur outside of the emberAfProcessMessage context, + // which leads to a bad memory reference - AHilton + if (emberAfCurrentCommand() != NULL) { + if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } + if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; + } + } + + // Fill commands may increase the sequence. For responses, we want to make + // sure the sequence is reset to that of the request. + if ((appResponseData[0] & ZCL_MANUFACTURER_SPECIFIC_MASK) != 0U) { + appResponseData[3] = emberAfIncomingZclSequenceNumber; + } else { + appResponseData[1] = emberAfIncomingZclSequenceNumber; + } + + // The manner in which the message is sent depends on the response flags and + // the destination of the message. + if ((emberAfResponseType & ZCL_UTIL_RESP_INTERPAN) != 0U) { + label = 'I'; + status = emberAfInterpanSendMessageCallback(&interpanResponseHeader, + appResponseLength, + appResponseData); + emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; + } else if (emberAfResponseDestination < EMBER_BROADCAST_ADDRESS) { + label = 'U'; + status = emberAfSendUnicastWithCallback(EMBER_OUTGOING_DIRECT, + emberAfResponseDestination, + &emberAfResponseApsFrame, + appResponseLength, + appResponseData, + callback); + } else { + label = 'B'; + status = emberAfSendBroadcastWithCallback(emberAfResponseDestination, + &emberAfResponseApsFrame, + appResponseLength, + appResponseData, + callback); + } + UNUSED_VAR(label); + emberAfDebugPrintln("T%4x:TX (%p) %ccast 0x%x%p", + emberAfGetCurrentTime(), + "resp", + label, + status, + ((emberAfResponseApsFrame.options + & EMBER_APS_OPTION_ENCRYPTION) + ? " w/ link key" : "")); + emberAfDebugPrint("TX buffer: ["); + emberAfDebugFlush(); + emberAfDebugPrintBuffer(appResponseData, appResponseLength, true); + emberAfDebugPrintln("]"); + emberAfDebugFlush(); + +#ifdef EMBER_AF_ENABLE_STATISTICS + if (status == EMBER_SUCCESS) { + afNumPktsSent++; + } +#endif + + return status; +} + +EmberStatus emberAfSendResponse(void) +{ + return emberAfSendResponseWithCallback(NULL); +} + +EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, + EmberAfMessageSentFunction callback) +{ + return emberAfSendDefaultResponseWithCallback(emberAfCurrentCommand(), status, callback); +} + +EmberStatus emberAfSendImmediateDefaultResponse(EmberAfStatus status) +{ + return emberAfSendImmediateDefaultResponseWithCallback(status, NULL); +} + +EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand *cmd, + EmberAfStatus status, + EmberAfMessageSentFunction callback) +{ + uint8_t frameControl; + + // Default Response commands are only sent in response to unicast commands. + if (cmd->type != EMBER_INCOMING_UNICAST + && cmd->type != EMBER_INCOMING_UNICAST_REPLY) { + return EMBER_SUCCESS; + } + + // If the Disable Default Response sub-field is set, Default Response commands + // are only sent if there was an error. + if ((cmd->buffer[0] & ZCL_DISABLE_DEFAULT_RESPONSE_MASK) + && status == EMBER_ZCL_STATUS_SUCCESS) { + return EMBER_SUCCESS; + } + + // Default Response commands are never sent in response to other Default + // Response commands. + if (!cmd->clusterSpecific + && cmd->commandId == ZCL_DEFAULT_RESPONSE_COMMAND_ID) { + return EMBER_SUCCESS; + } + + appResponseLength = 0; + frameControl = (ZCL_GLOBAL_COMMAND + | (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT + : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER)); + + if (!cmd->mfgSpecific) { + emberAfPutInt8uInResp(frameControl & (uint8_t) ~ZCL_MANUFACTURER_SPECIFIC_MASK); + } else { + emberAfPutInt8uInResp(frameControl | ZCL_MANUFACTURER_SPECIFIC_MASK); + emberAfPutInt16uInResp(cmd->mfgCode); + } + emberAfPutInt8uInResp(cmd->seqNum); + emberAfPutInt8uInResp(ZCL_DEFAULT_RESPONSE_COMMAND_ID); + emberAfPutInt8uInResp(cmd->commandId); + emberAfPutInt8uInResp(status); + + prepareForResponse(cmd); + return emberAfSendResponseWithCallback(callback); +} + +EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand *cmd, + EmberAfStatus status) +{ + return emberAfSendDefaultResponseWithCallback(cmd, status, NULL); +} + +bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, + bool incoming, + bool broadcast, + EmberAfProfileId profileId, + EmberAfClusterId clusterId, + EmberNodeId remoteNodeId) +{ + (void)afNoSecurityForDefaultResponse; // remove warning if not used + + // If we have turned off all APS security (needed for testing), then just + // always return false. + if ((emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) || afNoSecurityForDefaultResponse) { + afNoSecurityForDefaultResponse = false; + return false; + } + + // NOTE: In general if it is a unicast, and one of the SE clusters, it + // requires APS encryption. A few special cases exists that we allow for + // but those must be explicitly spelled out here. + + // Assume that if the local device is broadcasting, even if it is using one + // of the SE clusters, this is okay. + if (!incoming && broadcast) { + return false; + } + + // At this point if the CLI command has been issued, it's safe to over any other settings + // and return. + // This change allows HA applications to use the CLI option to enable APS security. + if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_ENABLED) { + return true; + } else if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) { + //The default return value before this change. + return false; + } else { + // MISRA requires ..else if.. to have terminating else. + } + +#ifdef EMBER_AF_HAS_SECURITY_PROFILE_SE + if (emberAfIsCurrentSecurityProfileSmartEnergy()) { + // Check against profile IDs that use APS security on these clusters. + if (profileId != SE_PROFILE_ID && profileId != EMBER_WILDCARD_PROFILE_ID) { + return false; + } + + // Loopback packets do not require security + if (emberGetNodeId() == remoteNodeId) { + return false; + } + + // This list comes from Section 5.4.6 of the SE spec. + switch (clusterId) { + case ZCL_TIME_CLUSTER_ID: + case ZCL_COMMISSIONING_CLUSTER_ID: + case ZCL_PRICE_CLUSTER_ID: + case ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID: + case ZCL_SIMPLE_METERING_CLUSTER_ID: + case ZCL_MESSAGING_CLUSTER_ID: + case ZCL_TUNNELING_CLUSTER_ID: + case ZCL_GENERIC_TUNNEL_CLUSTER_ID: + case ZCL_PREPAYMENT_CLUSTER_ID: + case ZCL_CALENDAR_CLUSTER_ID: + case ZCL_DEVICE_MANAGEMENT_CLUSTER_ID: + case ZCL_EVENTS_CLUSTER_ID: + case ZCL_MDU_PAIRING_CLUSTER_ID: + case ZCL_ENERGY_MANAGEMENT_CLUSTER_ID: + case ZCL_SUB_GHZ_CLUSTER_ID: + return true; + case ZCL_OTA_BOOTLOAD_CLUSTER_ID: + if (commandId == ZCL_IMAGE_NOTIFY_COMMAND_ID && broadcast) { + return false; + } else { + return true; + } + default: + break; + } + } +#endif //EMBER_AF_HAS_SECURITY_PROFILE_SE + + // All works with all hubs commands require aps link key authorization + if (clusterId == ZCL_SL_WWAH_CLUSTER_ID) { + return true; + } + + if (emberAfClusterSecurityCustomCallback(profileId, + clusterId, + incoming, + commandId)) { + return true; + } + +//APS_TEST_SECURITY_DEFAULT at this point returns false. + return false; +} + +uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame) +{ + EmberNodeId destination = EMBER_UNKNOWN_NODE_ID; + uint8_t max = EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH; + + if ((apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { + max -= EMBER_AF_APS_ENCRYPTION_OVERHEAD; + } + if ((apsFrame->options & EMBER_APS_OPTION_SOURCE_EUI64) != 0U) { + max -= EUI64_SIZE; + } + if ((apsFrame->options & EMBER_APS_OPTION_DESTINATION_EUI64) != 0U) { + max -= EUI64_SIZE; + } + if ((apsFrame->options & EMBER_APS_OPTION_FRAGMENT) != 0U) { + max -= EMBER_AF_APS_FRAGMENTATION_OVERHEAD; + } + + switch (type) { + case EMBER_OUTGOING_DIRECT: + destination = indexOrDestination; + break; + case EMBER_OUTGOING_VIA_ADDRESS_TABLE: + destination = emberGetAddressTableRemoteNodeId(indexOrDestination); + break; + case EMBER_OUTGOING_VIA_BINDING: + destination = emberGetBindingRemoteNodeId(indexOrDestination); + break; + case EMBER_OUTGOING_MULTICAST: + // APS multicast messages include the two-byte group id and exclude the + // one-byte destination endpoint, for a net loss of an extra byte. + max--; + break; + case EMBER_OUTGOING_BROADCAST: + break; + default: + // MISRA requires default case. + break; + } + + max -= emberAfGetSourceRouteOverheadCallback(destination); + + return max; +} + +void emberAfCopyInt16u(uint8_t *data, uint16_t index, uint16_t x) +{ + data[index] = (uint8_t) ( ((x) ) & 0xFF); + data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); +} + +void emberAfCopyInt24u(uint8_t *data, uint16_t index, uint32_t x) +{ + data[index] = (uint8_t) ( ((x) ) & 0xFF); + data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); + data[index + 2] = (uint8_t) ( ((x) >> 16) & 0xFF); +} + +void emberAfCopyInt32u(uint8_t *data, uint16_t index, uint32_t x) +{ + data[index] = (uint8_t) ( ((x) ) & 0xFF); + data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); + data[index + 2] = (uint8_t) ( ((x) >> 16) & 0xFF); + data[index + 3] = (uint8_t) ( ((x) >> 24) & 0xFF); +} + +void emberAfCopyString(uint8_t *dest, uint8_t *src, uint8_t size) +{ + if ( src == NULL ) { + dest[0] = 0; // Zero out the length of string + } else if (src[0] == 0xFF) { + dest[0] = src[0]; + } else { + uint8_t length = emberAfStringLength(src); + if (size < length) { + length = size; + } + MEMMOVE(dest + 1, src + 1, length); + dest[0] = length; + } +} + +void emberAfCopyLongString(uint8_t *dest, uint8_t *src, uint16_t size) +{ + if ( src == NULL ) { + dest[0] = dest[1] = 0; // Zero out the length of string + } else if ((src[0] == 0xFF) + && (src[1] == 0xFF)) { + dest[0] = 0xFF; + dest[1] = 0xFF; + } else { + uint16_t length = emberAfLongStringLength(src); + if (size < length) { + length = size; + } + MEMMOVE(dest + 2, src + 2, length); + dest[0] = LOW_BYTE(length); + dest[1] = HIGH_BYTE(length); + } +} + +#if (BIGENDIAN_CPU) + #define EM_BIG_ENDIAN true +#else + #define EM_BIG_ENDIAN false +#endif + +// You can pass in val1 as NULL, which will assume that it is +// pointing to an array of all zeroes. This is used so that +// default value of NULL is treated as all zeroes. +int8_t emberAfCompareValues(uint8_t* val1, + uint8_t* val2, + uint8_t len, + bool signedNumber) +{ + uint8_t i, j, k; + if (signedNumber) { // signed number comparison + if (len <= 4) { // only number with 32-bits or less is supported + int32_t accum1 = 0x0; + int32_t accum2 = 0x0; + int32_t all1s = -1; + + for (i = 0; i < len; i++) { + j = (val1 == NULL + ? 0 + : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i]) + ); + accum1 |= j << (8 * (len - 1 - i)); + + k = (EM_BIG_ENDIAN + ? val2[i] + : val2[(len - 1) - i]); + accum2 |= k << (8 * (len - 1 - i)); + } + + // sign extending, no need for 32-bits numbers + if (len < 4) { + if ((accum1 & (1 << (8 * len - 1))) != 0) { // check sign + accum1 |= all1s - ((1 << (len * 8)) - 1); + } + if ((accum2 & (1 << (8 * len - 1))) != 0) { // check sign + accum2 |= all1s - ((1 << (len * 8)) - 1); + } + } + + if (accum1 > accum2) { + return 1; + } else if (accum1 < accum2) { + return -1; + } else { + return 0; + } + } else { // not supported + return 0; + } + } else { // regular unsigned number comparison + for (i = 0; i < len; i++) { + j = (val1 == NULL + ? 0 + : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i]) + ); + k = (EM_BIG_ENDIAN + ? val2[i] + : val2[(len - 1) - i]); + + if (j > k) { + return 1; + } else if (k > j) { + return -1; + } else { + // MISRA requires ..else if.. to have terminating else. + } + } + return 0; + } +} + +#if 0 +// Moving to time-util.c +int8_t emberAfCompareDates(EmberAfDate* date1, EmberAfDate* date2) +{ + uint32_t val1 = emberAfEncodeDate(date1); + uint32_t val2 = emberAfEncodeDate(date2); + return (val1 == val2) ? 0 : ((val1 < val2) ? -1 : 1); +} +#endif + +// returns the type that the attribute is, either EMBER_AF_DATA_TYPE_ANALOG, +// EMBER_AF_DATA_TYPE_DISCRETE, or EMBER_AF_DATA_TYPE_NONE. This is based on table +// 2.15 from the ZCL spec 075123r02 +uint8_t emberAfGetAttributeAnalogOrDiscreteType(uint8_t dataType) +{ + uint8_t index = 0; + + while ( emberAfAnalogDiscreteThresholds[index] < dataType ) { + index += 2; + } + return emberAfAnalogDiscreteThresholds[index + 1]; +} + +// Zigbee spec says types between signed 8 bit and signed 64 bit +bool emberAfIsTypeSigned(EmberAfAttributeType dataType) +{ + return (dataType >= ZCL_INT8S_ATTRIBUTE_TYPE + && dataType <= ZCL_INT64S_ATTRIBUTE_TYPE); +} + +EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl *controls, + uint8_t endpoint) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) { + return EMBER_INVALID_ENDPOINT; + } + emberEventControlSetInactive(controls[index]); + return EMBER_SUCCESS; +} + +bool emberAfEndpointEventControlGetActive(EmberEventControl *controls, + uint8_t endpoint) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + return (index != 0xFF && emberEventControlGetActive(controls[index])); +} + +EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, + uint8_t endpoint) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) { + return EMBER_INVALID_ENDPOINT; + } + emberEventControlSetActive(controls[index]); + return EMBER_SUCCESS; +} + +EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl *controls, + uint8_t endpoint, + uint32_t delayMs) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayMS(&controls[index], delayMs); +} + +EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl *controls, + uint8_t endpoint, + uint32_t delayQs) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayQS(&controls[index], delayQs); +} + +EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl *controls, + uint8_t endpoint, + uint16_t delayM) +{ + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayMinutes(&controls[index], delayM); +} + +bool emberAfIsThisMyEui64(EmberEUI64 eui64) +{ + EmberEUI64 myEui64; + emberAfGetEui64(myEui64); + return (0 == MEMCOMPARE(eui64, myEui64, EUI64_SIZE) + ? true + : false); +} + +uint8_t emberAfAppendCharacters(uint8_t * zclString, + uint8_t zclStringMaxLen, + const uint8_t * appendingChars, + uint8_t appendingCharsLen) +{ + uint8_t freeChars; + uint8_t curLen; + uint8_t charsToWrite; + + if ((zclString == NULL) + || (zclStringMaxLen == 0) + || (appendingChars == NULL) + || (appendingCharsLen == 0)) { + return 0; + } + + curLen = emberAfStringLength(zclString); + + if ((zclString[0] == 0xFF) + || (curLen >= zclStringMaxLen)) { + return 0; + } + + freeChars = zclStringMaxLen - curLen; + charsToWrite = (freeChars > appendingCharsLen) ? appendingCharsLen : freeChars; + + MEMCOPY(&zclString[1 + curLen], // 1 is to account for zcl's length byte + appendingChars, + charsToWrite); + zclString[0] = curLen + charsToWrite; + return charsToWrite; +} + +uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initialValue) +{ + uint16_t i; + uint32_t crc32 = initialValue; + for (i = 0; i < length; i++) { + crc32 = halCommonCrc32(pbuffer[i], crc32); + } + return crc32; +} + +/* + On each page, first channel maps to channel number zero and so on. + Example: + page Band Rage of 90 channels Per page channel mapping + 28 863 MHz 0-26 0-26 + 29 863 MHz 27-34,62 0-8 (Here 7th channel maps to 34 and 8th to 62) + 30 863 MHz 35 - 61 0-26 + 31 915 0-26 0-26 + + */ +EmberStatus emAfValidateChannelPages(uint8_t page, uint8_t channel) +{ + switch (page) { + case 0: + if (!((channel <= EMBER_MAX_802_15_4_CHANNEL_NUMBER) + && ((EMBER_MIN_802_15_4_CHANNEL_NUMBER == 0) + || (channel >= EMBER_MIN_802_15_4_CHANNEL_NUMBER)))) { + return EMBER_PHY_INVALID_CHANNEL; + } + break; + case 28: + case 30: + case 31: + if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31) { + return EMBER_PHY_INVALID_CHANNEL; + } + break; + case 29: + if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29) { + return EMBER_PHY_INVALID_CHANNEL; + } + break; + default: + return EMBER_PHY_INVALID_CHANNEL; + break; + } + return EMBER_SUCCESS; +} + +void slabAssert(const char * file, int line) +{ + (void)file; // Unused parameter + (void)line; // Unused parameter + // Wait forever until the watchdog fires + while (true) { + } +} + +#define ENCODED_8BIT_CHANPG_PAGE_MASK 0xE0 // top 3 bits +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0 0x00 // 0b000xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28 0x80 // 0b100xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29 0xA0 // 0b101xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30 0xC0 // 0b110xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31 0xE0 // 0b111xxxxx + +#define ENCODED_8BIT_CHANPG_CHANNEL_MASK 0x1F // bottom 5 bits + +uint8_t emberAfGetPageFrom8bitEncodedChanPg(uint8_t chanPg) +{ + switch (chanPg & ENCODED_8BIT_CHANPG_PAGE_MASK) { + case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0: + return 0; + case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28: + return 28; + case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29: + return 29; + case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30: + return 30; + case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31: + return 31; + default: + return 0xFF; + } +} + +uint8_t emberAfGetChannelFrom8bitEncodedChanPg(uint8_t chanPg) +{ + return chanPg & ENCODED_8BIT_CHANPG_CHANNEL_MASK; +} + +uint8_t emberAfMake8bitEncodedChanPg(uint8_t page, uint8_t channel) +{ + if (emAfValidateChannelPages(page, channel) != EMBER_SUCCESS) { + return 0xFF; + } + + switch (page) { + case 28: + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28; + case 29: + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29; + case 30: + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30; + case 31: + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31; + default: + // Strictly speaking, we only need case 0 here, but MISRA in its infinite + // wisdom requires a default case. Since we have validated the arguments + // already, and 0 is the only remaining case, we simply treat the default + // as case 0 to make MISRA happy. + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0; + } +} diff --git a/examples/wifi-echo/server/esp32/main/util.h b/examples/wifi-echo/server/esp32/main/util.h new file mode 100644 index 00000000000000..01f75e07a8384a --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/util.h @@ -0,0 +1,320 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/***************************************************************************//** + * @file + * @brief + ******************************************************************************* + ******************************************************************************/ + +// ******************************************************************* +// * util.h +// * +// * +// * Copyright 2007-2017 by Silicon Laboratories. All rights reserved. *80* +// ******************************************************************* + +#ifndef __AF_UTIL_H__ +#define __AF_UTIL_H__ + +// User asserts can override SLAB_ASSERT and should be defined as follows: +// void userAssert (int file, int line); // declaration +// #define USER_ASSERT(file, line) userAssert(file, line) // definition + +#if defined(NO_ASSERT) + #define SLAB_ASSERT(expr) +#else + #if defined(USER_ASSERT) + #define SLAB_ASSERT(expr) \ + ((expr) ? ((void)0) : USER_ASSERT(__FILE__, __LINE__)) + #else + #define SLAB_ASSERT(expr) \ + ((expr) ? ((void)0) : slabAssert(__FILE__, __LINE__)) + #endif // USER_ASSERT +#endif // NO_ASSERT + +// This controls the type of response. Normally The library sends an automatic +// response (if appropriate) on the same PAN. The reply can be disabled by +// calling emberAfSetNoReplyForNextMessage. +#define ZCL_UTIL_RESP_NORMAL 0 +#define ZCL_UTIL_RESP_NONE 1 +#define ZCL_UTIL_RESP_INTERPAN 2 + +// Cluster name structure +typedef struct { + uint16_t id; + uint16_t mfgCode; + const char * name; +} EmberAfClusterName; + +extern const EmberAfClusterName zclClusterNames[]; + +#define ZCL_NULL_CLUSTER_ID 0xFFFF + +#include "../include/af.h" + +// Override APS retry: 0 - don't touch, 1 - always set, 2 - always unset +typedef enum { + EMBER_AF_RETRY_OVERRIDE_NONE = 0, + EMBER_AF_RETRY_OVERRIDE_SET = 1, + EMBER_AF_RETRY_OVERRIDE_UNSET = 2 +} EmberAfRetryOverride; + +// The default APS retry flag value is controlled by EMBER_AF_DEFAULT_APS_OPTIONS +// and is usually 1. In high traffic, low bandwidth networks (e.g. sub-GHz), +// the app may want to override this. Two methods are available for apps that +// may wants to do this dynamically per message: +// 1. Call emberAfSetRetryOverride each time before filling the message buffer; +// 2. Call emberAfSetRetryOverride once with a value covering most messages and +// then toggling the flag as necessary in emberAfPreMessageSendCallback. +void emberAfSetRetryOverride(EmberAfRetryOverride value); + +// Return the current override status +EmberAfRetryOverride emberAfGetRetryOverride(void); + +// This function applies the curent override value to the APS options. +// It is called internally by the framework in the final stages of filling the +// message buffer. +void emAfApplyRetryOverride(EmberApsOption *options); + +// Override Disable Default Response flag in the ZCL Frame Control +typedef enum { + EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE = 0, // no override + EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT = 1, // next message only + EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT = 2 // until cancelled +} EmberAfDisableDefaultResponse; + +// The default value for the Disable Default Response flag in ZCL Frame Control +// is 0 (i.e. default responses are generated). The app can disable default +// reponses either for the next message only or for all messages until another +// call to this function. +void emberAfSetDisableDefaultResponse(EmberAfDisableDefaultResponse value); + +// Return the current status +EmberAfDisableDefaultResponse emberAfGetDisableDefaultResponse(void); + +// This function applies the curent override value to the ZCL Frame Control. +// It is called internally by the framework in the final stages of filling the +// message buffer. +void emAfApplyDisableDefaultResponse(uint8_t *frame_control); + +// Returns a mfg code from current command. +// This should only be used within the command parsing context. +// Wraps emberAfCurrentCommand(), and assumes that the current comamnd +// is either the current valid command or NULL +// In the case of NULL, then it returns EMBER_AF_NULL_MANUFACTURER_CODE +uint16_t emberAfGetMfgCodeFromCurrentCommand(void); + +// EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH is defined in config.h +#define EMBER_AF_RESPONSE_BUFFER_LEN EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH + +void emberAfInit(void); +void emberAfTick(void); +uint16_t emberAfFindClusterNameIndex(uint16_t cluster); +uint16_t emberAfFindClusterNameIndexWithMfgCode(uint16_t cluster, uint16_t mfgCode); +void emberAfStackDown(void); + +void emberAfDecodeAndPrintCluster(uint16_t cluster); +void emberAfDecodeAndPrintClusterWithMfgCode(uint16_t cluster, uint16_t mfgCode); + +bool emberAfProcessMessage(EmberApsFrame *apsFrame, + EmberIncomingMessageType type, + uint8_t *message, + uint16_t msgLen, + EmberNodeId source, + InterPanHeader *interPanHeader); + +bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, + EmberIncomingMessageType type, + uint8_t* message, + uint16_t messageLength, + EmberNodeId source, + InterPanHeader* interPanHeader, + EmberAfClusterCommand* returnCmd); + +/** + * Retrieves the difference between the two passed values. + * This function assumes that the two values have the same endianness. + * On platforms that support 64-bit primitive types, this function will work + * on data sizes up to 8 bytes. Otherwise, it will only work on data sizes of + * up to 4 bytes. + */ +EmberAfDifferenceType emberAfGetDifference(uint8_t* pData, + EmberAfDifferenceType value, + uint8_t dataSize); + +/** + * Retrieves an uint32_t from the given Zigbee payload. The integer retrieved + * may be cast into an integer of the appropriate size depending on the + * number of bytes requested from the message. In Zigbee, all integers are + * passed over the air in LSB form. LSB to MSB conversion is + * done within this function automatically before the integer is returned. + * + * Obviously (due to return value) this function can only handle + * the retrieval of integers between 1 and 4 bytes in length. + * + */ +uint32_t emberAfGetInt(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen, uint8_t bytes); + +void emberAfClearResponseData(void); +uint8_t * emberAfPutInt8uInResp(uint8_t value); +uint16_t * emberAfPutInt16uInResp(uint16_t value); +uint32_t * emberAfPutInt32uInResp(uint32_t value); +uint32_t * emberAfPutInt24uInResp(uint32_t value); +uint8_t * emberAfPutBlockInResp(const uint8_t* data, uint16_t length); +uint8_t * emberAfPutStringInResp(const uint8_t *buffer); +uint8_t * emberAfPutDateInResp(EmberAfDate *value); + +bool emberAfIsThisMyEui64(EmberEUI64 eui64); + +uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initialValue); + +// If the variable has not been set, APS_TEST_SECURITY_DEFAULT will +// eventually return false. +enum { + APS_TEST_SECURITY_ENABLED = 0, + APS_TEST_SECURITY_DISABLED = 1, + APS_TEST_SECURITY_DEFAULT = 2, +}; +extern uint8_t emAfTestApsSecurityOverride; + +#ifdef EZSP_HOST +// the EM260 host application is expected to provide these functions if using +// a cluster that needs it. +EmberNodeId emberGetSender(void); +EmberStatus emberGetSenderEui64(EmberEUI64 senderEui64); +#endif //EZSP_HOST + +// DEPRECATED. +extern uint8_t emberAfIncomingZclSequenceNumber; + +// the caller to the library can set a flag to say do not respond to the +// next ZCL message passed in to the library. Passing true means disable +// the reply for the next ZCL message. Setting to false re-enables the +// reply (in the case where the app disables it and then doesnt send a +// message that gets parsed). +void emberAfSetNoReplyForNextMessage(bool set); + +// this function determines if APS Link key should be used to secure +// the message. It is based on the clusterId and specified in the SE +// app profile. If the message is outgoing then the +bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, + bool incoming, + bool broadcast, + EmberAfProfileId profileId, + EmberAfClusterId clusterId, + EmberNodeId remoteNodeId); + +#define isThisDataTypeSentLittleEndianOTA(dataType) \ + (!(emberAfIsThisDataTypeAStringType(dataType))) + +bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd); +bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand *cmd); + +extern uint8_t emberAfResponseType; + +uint16_t emberAfStrnlen(const uint8_t* string, uint16_t maxLength); + +/* @brief Append characters to a ZCL string. + * + * Appending characters to an existing ZCL string. If it is an invalid string + * (length byte equals 0xFF), no characters will be appended. + * + * @param zclString - pointer to the zcl string + * @param zclStringMaxLen - length of zcl string (does not include zcl length byte) + * @param src - pointer to plain text characters + * @param srcLen - length of plain text characters + * + * @return number of characters appended + * + */ +uint8_t emberAfAppendCharacters(uint8_t * zclString, + uint8_t zclStringMaxLen, + const uint8_t * appendingChars, + uint8_t appendingCharsLen); + +extern uint8_t emAfExtendedPanId[]; + +EmberStatus emAfValidateChannelPages(uint8_t page, uint8_t channel); + +/* @brief A Silicon Labs assert function + * + * This function is provided to call an assert function in the application code. + * It starts an infinite loop that provokes the watchdog to fire. + * + * @param file - the source file that calls this assert + * @param line - the line that calls this assert + * + * @return void + * + */ +void slabAssert(const char * file, int line); + +/* @brief Get the page number from an 8-bit encoded channel-page + * + * The top three bits denote the page number, like this: + * 000x xxxx = page 0 + * 100x xxxx = page 28 + * 101x xxxx = page 29 + * 110x xxxx = page 30 + * 111x xxxx = page 31 + * + * @param chanPg - 8-bit encoded channel and page + * + * @return page number (0, 28-31, 0xFF if invalid) + */ +uint8_t emberAfGetPageFrom8bitEncodedChanPg(uint8_t chanPg); + +/* @brief Get the channel number from an 8-bit encoded channel-page + * + * The bottom 5 bits denote the channel within the page. + * + * Provided for symmetry with the above emberAfGetPageFrom8bitEncodedChanPg(). + * It simply masks the bottom 5 bits. + * + * @param chanPg - 8-bit encoded channel and page + * + * @return channel number (0-8, 0-26, 11-26, depending on the page) + */ +uint8_t emberAfGetChannelFrom8bitEncodedChanPg(uint8_t chanPg); + +/* @brief Make an 8-bit encoded channel-page from channel and page arguments + * + * @param page + * @param channel + * + * @return 8-bit encoded channel-page, 0xFF if invalid + */ +uint8_t emberAfMake8bitEncodedChanPg(uint8_t page, uint8_t channel); + +#endif // __AF_UTIL_H__ From 695f3ffce3259e5e3fbb1d39198d23f85f5c24e0 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 2 Jul 2020 14:50:42 -0400 Subject: [PATCH 02/12] Add generated files from the Silicon Labs sample app provided by Ezra Hale. The sample app only implements the On/Off cluster. Most of the files have the same exact name as in the sample app, with the following exceptions: * endpoint_config.h was originally ZigbeeMinimalSoc_endpoint_config.h * gen_config.h was originally ZigbeeMinimalSoc.h * gen_tokens.h was originally ZigbeeMinimalSoc_tokens.h --- .../wifi-echo/server/esp32/main/component.mk | 2 + .../server/esp32/main/gen/af-structs.h | 463 + .../server/esp32/main/gen/att-storage.h | 91 + .../server/esp32/main/gen/attribute-id.h | 4796 +++ .../server/esp32/main/gen/attribute-size.h | 68 + .../server/esp32/main/gen/attribute-type.h | 103 + .../esp32/main/gen/call-command-handler.c | 137 + .../esp32/main/gen/call-command-handler.h | 49 + .../server/esp32/main/gen/callback-stub.c | 2689 ++ .../server/esp32/main/gen/callback.h | 26485 ++++++++++++++++ .../esp32/main/gen/client-command-macro.h | 14295 +++++++++ .../server/esp32/main/gen/cluster-id.h | 175 + .../server/esp32/main/gen/command-id.h | 1095 + .../server/esp32/main/gen/debug-printing.h | 2354 ++ .../server/esp32/main/gen/endpoint_config.h | 140 + .../wifi-echo/server/esp32/main/gen/enums.h | 3359 ++ .../server/esp32/main/gen/gen_config.h | 269 + .../server/esp32/main/gen/gen_tokens.h | 63 + .../server/esp32/main/gen/print-cluster.h | 707 + .../server/esp32/main/gen/znet-bookkeeping.c | 121 + .../server/esp32/main/gen/znet-bookkeeping.h | 67 + 21 files changed, 57528 insertions(+) create mode 100644 examples/wifi-echo/server/esp32/main/gen/af-structs.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/att-storage.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/attribute-id.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/attribute-size.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/attribute-type.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/call-command-handler.c create mode 100644 examples/wifi-echo/server/esp32/main/gen/call-command-handler.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/callback-stub.c create mode 100644 examples/wifi-echo/server/esp32/main/gen/callback.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/client-command-macro.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/cluster-id.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/command-id.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/debug-printing.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/endpoint_config.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/enums.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/gen_config.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/gen_tokens.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/print-cluster.h create mode 100644 examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c create mode 100644 examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h diff --git a/examples/wifi-echo/server/esp32/main/component.mk b/examples/wifi-echo/server/esp32/main/component.mk index 05d17862675f02..5960c1007122b7 100644 --- a/examples/wifi-echo/server/esp32/main/component.mk +++ b/examples/wifi-echo/server/esp32/main/component.mk @@ -20,3 +20,5 @@ # (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) COMPONENT_DEPENDS := chip QRCode tft spidriver + +COMPONENT_SRCDIRS := . gen diff --git a/examples/wifi-echo/server/esp32/main/gen/af-structs.h b/examples/wifi-echo/server/esp32/main/gen/af-structs.h new file mode 100644 index 00000000000000..400e3a410db135 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/af-structs.h @@ -0,0 +1,463 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_STRUCTS +#define SILABS_EMBER_AF_STRUCTS + + +// Generated structs from the metadata +// Struct for IasAceZoneStatusResult +typedef struct _IasAceZoneStatusResult { + uint8_t zoneId; + uint16_t zoneStatus; +} IasAceZoneStatusResult; + + +// Struct for ReadAttributeStatusRecord +typedef struct _ReadAttributeStatusRecord { + uint16_t attributeId; + uint8_t status; + uint8_t attributeType; + uint8_t* attributeLocation; +} ReadAttributeStatusRecord; + + +// Struct for WriteAttributeRecord +typedef struct _WriteAttributeRecord { + uint16_t attributeId; + uint8_t attributeType; + uint8_t* attributeLocation; +} WriteAttributeRecord; + + +// Struct for WriteAttributeStatusRecord +typedef struct _WriteAttributeStatusRecord { + uint8_t status; + uint16_t attributeId; +} WriteAttributeStatusRecord; + + +// Struct for ConfigureReportingRecord +typedef struct _ConfigureReportingRecord { + uint8_t direction; + uint16_t attributeId; + uint8_t attributeType; + uint16_t minimumReportingInterval; + uint16_t maximumReportingInterval; + uint8_t* reportableChangeLocation; + uint16_t timeoutPeriod; +} ConfigureReportingRecord; + + +// Struct for ConfigureReportingStatusRecord +typedef struct _ConfigureReportingStatusRecord { + uint8_t status; + uint8_t direction; + uint16_t attributeId; +} ConfigureReportingStatusRecord; + + +// Struct for ReadReportingConfigurationRecord +typedef struct _ReadReportingConfigurationRecord { + uint8_t status; + uint8_t direction; + uint16_t attributeId; + uint8_t attributeType; + uint16_t minimumReportingInterval; + uint16_t maximumReportingInterval; + uint8_t* reportableChangeLocation; + uint16_t timeoutPeriod; +} ReadReportingConfigurationRecord; + + +// Struct for ReadReportingConfigurationAttributeRecord +typedef struct _ReadReportingConfigurationAttributeRecord { + uint8_t direction; + uint16_t attributeId; +} ReadReportingConfigurationAttributeRecord; + + +// Struct for ReportAttributeRecord +typedef struct _ReportAttributeRecord { + uint16_t attributeId; + uint8_t attributeType; + uint8_t* attributeLocation; +} ReportAttributeRecord; + + +// Struct for DiscoverAttributesInfoRecord +typedef struct _DiscoverAttributesInfoRecord { + uint16_t attributeId; + uint8_t attributeType; +} DiscoverAttributesInfoRecord; + + +// Struct for ExtendedDiscoverAttributesInfoRecord +typedef struct _ExtendedDiscoverAttributesInfoRecord { + uint16_t attributeId; + uint8_t attributeType; + uint8_t attributeAccessControl; +} ExtendedDiscoverAttributesInfoRecord; + + +// Struct for ReadStructuredAttributeRecord +typedef struct _ReadStructuredAttributeRecord { + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; +} ReadStructuredAttributeRecord; + + +// Struct for WriteStructuredAttributeRecord +typedef struct _WriteStructuredAttributeRecord { + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; + uint8_t attributeType; + uint8_t* attributeLocation; +} WriteStructuredAttributeRecord; + + +// Struct for WriteStructuredAttributeStatusRecord +typedef struct _WriteStructuredAttributeStatusRecord { + uint8_t status; + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; +} WriteStructuredAttributeStatusRecord; + + +// Struct for SceneExtensionAttributeInfo +typedef struct _SceneExtensionAttributeInfo { + uint8_t attributeType; + uint8_t* attributeLocation; +} SceneExtensionAttributeInfo; + + +// Struct for SceneExtensionFieldSet +typedef struct _SceneExtensionFieldSet { + uint16_t clusterId; + uint8_t length; + uint8_t value; +} SceneExtensionFieldSet; + + +// Struct for BlockThreshold +typedef struct _BlockThreshold { + uint8_t blockThreshold; + uint8_t priceControl; + uint32_t blockPeriodStartTime; + uint32_t blockPeriodDurationMinutes; + uint8_t fuelType; + uint32_t standingCharge; +} BlockThreshold; + + +// Struct for Notification +typedef struct _Notification { + uint16_t contentId; + uint8_t statusFeedback; +} Notification; + + +// Struct for NeighborInfo +typedef struct _NeighborInfo { + uint8_t* neighbor; + int16_t x; + int16_t y; + int16_t z; + int8_t rssi; + uint8_t numberRssiMeasurements; +} NeighborInfo; + + +// Struct for ChatParticipant +typedef struct _ChatParticipant { + uint16_t uid; + uint8_t* nickname; +} ChatParticipant; + + +// Struct for ChatRoom +typedef struct _ChatRoom { + uint16_t cid; + uint8_t* name; +} ChatRoom; + + +// Struct for NodeInformation +typedef struct _NodeInformation { + uint16_t uid; + uint16_t address; + uint8_t endpoint; + uint8_t* nickname; +} NodeInformation; + + +// Struct for ScheduledPhase +typedef struct _ScheduledPhase { + uint8_t energyPhaseId; + uint16_t scheduledTime; +} ScheduledPhase; + + +// Struct for TransferredPhase +typedef struct _TransferredPhase { + uint8_t energyPhaseId; + uint8_t macroPhaseId; + uint16_t expectedDuration; + uint16_t peakPower; + uint16_t energy; + uint16_t maxActivationDelay; +} TransferredPhase; + + +// Struct for PowerProfileRecord +typedef struct _PowerProfileRecord { + uint8_t powerProfileId; + uint8_t energyPhaseId; + uint8_t powerProfileRemoteControl; + uint8_t powerProfileState; +} PowerProfileRecord; + + +// Struct for PriceMatrixSubPayload +typedef struct _PriceMatrixSubPayload { + uint8_t tierBlockId; + uint32_t price; +} PriceMatrixSubPayload; + + +// Struct for BlockThresholdSubPayload +typedef struct _BlockThresholdSubPayload { + uint8_t tierNumberOfBlockThresholds; + uint8_t* blockThreshold; +} BlockThresholdSubPayload; + + +// Struct for TierLabelsPayload +typedef struct _TierLabelsPayload { + uint8_t tierId; + uint8_t* tierLabel; +} TierLabelsPayload; + + +// Void typedef for Signature which is empty. +// this will result in all the references to the data being as uint8_t* +typedef uint8_t Signature; + + +// Struct for SnapshotResponsePayload +typedef struct _SnapshotResponsePayload { + uint8_t snapshotScheduleId; + uint8_t snapshotScheduleConfirmation; +} SnapshotResponsePayload; + + +// Struct for SnapshotSchedulePayload +typedef struct _SnapshotSchedulePayload { + uint8_t snapshotScheduleId; + uint32_t snapshotStartTime; + uint32_t snapshotSchedule; + uint8_t snapshotPayloadType; + uint32_t snapshotCause; +} SnapshotSchedulePayload; + + +// Struct for Protocol +typedef struct _Protocol { + uint16_t manufacturerCode; + uint8_t protocolId; +} Protocol; + + +// Struct for TopUpPayload +typedef struct _TopUpPayload { + uint8_t* topUpCode; + int32_t topUpAmount; + uint32_t topUpTime; +} TopUpPayload; + + +// Struct for DebtPayload +typedef struct _DebtPayload { + uint32_t collectionTime; + uint32_t amountCollected; + uint8_t debtType; + uint32_t outstandingDebt; +} DebtPayload; + + +// Struct for ScheduleEntry +typedef struct _ScheduleEntry { + uint16_t startTime; + uint8_t activePriceTierOrFriendlyCreditEnable; +} ScheduleEntry; + + +// Struct for ScheduleEntryRateSwitchTimes +typedef struct _ScheduleEntryRateSwitchTimes { + uint16_t startTime; + uint8_t priceTier; +} ScheduleEntryRateSwitchTimes; + + +// Struct for ScheduleEntryFriendlyCreditSwitchTimes +typedef struct _ScheduleEntryFriendlyCreditSwitchTimes { + uint16_t startTime; + uint8_t friendlyCreditEnable; +} ScheduleEntryFriendlyCreditSwitchTimes; + + +// Struct for ScheduleEntryAuxilliaryLoadSwitchTimes +typedef struct _ScheduleEntryAuxilliaryLoadSwitchTimes { + uint16_t startTime; + uint8_t auxiliaryLoadSwitchState; +} ScheduleEntryAuxilliaryLoadSwitchTimes; + + +// Struct for SeasonEntry +typedef struct _SeasonEntry { + uint32_t seasonStartDate; + uint8_t weekIdRef; +} SeasonEntry; + + +// Struct for SpecialDay +typedef struct _SpecialDay { + uint32_t specialDayDate; + uint8_t dayIdRef; +} SpecialDay; + + +// Struct for EventConfigurationPayload +typedef struct _EventConfigurationPayload { + uint16_t eventId; + uint8_t eventConfiguration; +} EventConfigurationPayload; + + +// Struct for EventLogPayload +typedef struct _EventLogPayload { + uint8_t logId; + uint16_t eventId; + uint32_t eventTime; + uint8_t* eventData; +} EventLogPayload; + + +// Void typedef for Identity which is empty. +// this will result in all the references to the data being as uint8_t* +typedef uint8_t Identity; + + +// Void typedef for EphemeralData which is empty. +// this will result in all the references to the data being as uint8_t* +typedef uint8_t EphemeralData; + + +// Void typedef for Smac which is empty. +// this will result in all the references to the data being as uint8_t* +typedef uint8_t Smac; + + +// Struct for DeviceInformationRecord +typedef struct _DeviceInformationRecord { + uint8_t* ieeeAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; + uint8_t groupIdCount; + uint8_t sort; +} DeviceInformationRecord; + + +// Struct for GroupInformationRecord +typedef struct _GroupInformationRecord { + uint16_t groupId; + uint8_t groupType; +} GroupInformationRecord; + + +// Struct for EndpointInformationRecord +typedef struct _EndpointInformationRecord { + uint16_t networkAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; +} EndpointInformationRecord; + + +// Struct for GpTranslationTableUpdateTranslation +typedef struct _GpTranslationTableUpdateTranslation { + uint8_t index; + uint8_t gpdCommandId; + uint8_t endpoint; + uint16_t profile; + uint16_t cluster; + uint8_t zigbeeCommandId; + uint8_t* zigbeeCommandPayload; + uint8_t* additionalInfoBlock; +} GpTranslationTableUpdateTranslation; + + +// Struct for GpPairingConfigurationGroupList +typedef struct _GpPairingConfigurationGroupList { + uint16_t SinkGroup; + uint16_t Alias; +} GpPairingConfigurationGroupList; + + +// Struct for WwahBeaconSurvey +typedef struct _WwahBeaconSurvey { + uint16_t deviceShort; + uint8_t rssi; + uint8_t classificationMask; +} WwahBeaconSurvey; + + +// Struct for WwahClusterStatusToUseTC +typedef struct _WwahClusterStatusToUseTC { + uint16_t clusterId; + uint8_t status; +} WwahClusterStatusToUseTC; + + +#endif // SILABS_EMBER_AF_STRUCTS diff --git a/examples/wifi-echo/server/esp32/main/gen/att-storage.h b/examples/wifi-echo/server/esp32/main/gen/att-storage.h new file mode 100644 index 00000000000000..e67c5f5053982b --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/att-storage.h @@ -0,0 +1,91 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_ATTRIBUTE_STORAGE_GEN +#define SILABS_ATTRIBUTE_STORAGE_GEN + + + +// Attribute masks modify how attributes are used by the framework +// Attribute that has this mask is NOT read-only +#define ATTRIBUTE_MASK_WRITABLE (0x01) +// Attribute that has this mask is saved to a token +#define ATTRIBUTE_MASK_TOKENIZE (0x02) +// Attribute that has this mask has a min/max values +#define ATTRIBUTE_MASK_MIN_MAX (0x04) +// Manufacturer specific attribute +#define ATTRIBUTE_MASK_MANUFACTURER_SPECIFIC (0x08) +// Attribute deferred to external storage +#define ATTRIBUTE_MASK_EXTERNAL_STORAGE (0x10) +// Attribute is singleton +#define ATTRIBUTE_MASK_SINGLETON (0x20) +// Attribute is a client attribute +#define ATTRIBUTE_MASK_CLIENT (0x40) + + +// Cluster masks modify how clusters are used by the framework +// Does this cluster have init function? +#define CLUSTER_MASK_INIT_FUNCTION (0x01) +// Does this cluster have attribute changed function? +#define CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION (0x02) +// Does this cluster have default response function? +#define CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION (0x04) +// Does this cluster have message sent function? +#define CLUSTER_MASK_MESSAGE_SENT_FUNCTION (0x08) +// Does this cluster have manufacturer specific attribute changed funciton? +#define CLUSTER_MASK_MANUFACTURER_SPECIFIC_ATTRIBUTE_CHANGED_FUNCTION (0x10) +// Does this cluster have pre-attribute changed function? +#define CLUSTER_MASK_PRE_ATTRIBUTE_CHANGED_FUNCTION (0x20) +// Cluster is a server +#define CLUSTER_MASK_SERVER (0x40) +// Cluster is a client +#define CLUSTER_MASK_CLIENT (0x80) + + +// Command masks modify meanings of commands +// Is sending of this client command supported +#define COMMAND_MASK_OUTGOING_CLIENT (0x01) +// Is sending of this server command supported +#define COMMAND_MASK_OUTGOING_SERVER (0x02) +// Is receiving of this client command supported +#define COMMAND_MASK_INCOMING_CLIENT (0x04) +// Is receiving of this server command supported +#define COMMAND_MASK_INCOMING_SERVER (0x08) +// Is this command manufacturer specific? +#define COMMAND_MASK_MANUFACTURER_SPECIFIC (0x10) +#endif // SILABS_ATTRIBUTE_STORAGE_GEN diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-id.h b/examples/wifi-echo/server/esp32/main/gen/attribute-id.h new file mode 100644 index 00000000000000..674c982bfc4d6f --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-id.h @@ -0,0 +1,4796 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_ATTRIBUTE_ID +#define SILABS_EMBER_AF_ATTRIBUTE_ID + + +// Attribute types for cluster: Basic +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_BASIC_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BASIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_VERSION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_APPLICATION_VERSION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_STACK_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HW_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MANUFACTURER_NAME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MODEL_IDENTIFIER_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_DATE_CODE_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_POWER_SOURCE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_GENERIC_DEVICE_CLASS_ATTRIBUTE_ID 0x0008 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_GENERIC_DEVICE_TYPE_ATTRIBUTE_ID 0x0009 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_PRODUCT_CODE_ATTRIBUTE_ID 0x000A // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_PRODUCT_URL_ATTRIBUTE_ID 0x000B // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_LOCATION_DESCRIPTION_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PHYSICAL_ENVIRONMENT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_DEVICE_ENABLED_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_ALARM_MASK_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_DISABLE_LOCAL_CONFIG_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_CURRENT_LOCALE_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_SW_BUILD_ID_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_BASIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BASIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Power Configuration +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_POWER_CONFIG_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POWER_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MAINS_VOLTAGE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAINS_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAINS_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_MAINS_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_MAINS_VOLTAGE_MAX_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_MAINS_VOLTAGE_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_BATTERY_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_MANUFACTURER_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_BATTERY_SIZE_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_BATTERY_AHR_RATING_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_BATTERY_QUANTITY_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_BATTERY_RATED_VOLTAGE_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_BATTERY_ALARM_MASK_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0037 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0038 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0039 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x003A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x003B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x003C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x003D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_ALARM_STATE_ATTRIBUTE_ID 0x003E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_MANUFACTURER_ATTRIBUTE_ID 0x0050 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_SIZE_ATTRIBUTE_ID 0x0051 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_AHR_RATING_ATTRIBUTE_ID 0x0052 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_QUANTITY_ATTRIBUTE_ID 0x0053 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_RATED_VOLTAGE_ATTRIBUTE_ID 0x0054 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_ALARM_MASK_ATTRIBUTE_ID 0x0055 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0056 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0057 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0058 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0059 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x005A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x005B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x005C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x005D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_ALARM_STATE_ATTRIBUTE_ID 0x005E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_ATTRIBUTE_ID 0x0060 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0061 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_MANUFACTURER_ATTRIBUTE_ID 0x0070 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_SIZE_ATTRIBUTE_ID 0x0071 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_AHR_RATING_ATTRIBUTE_ID 0x0072 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_QUANTITY_ATTRIBUTE_ID 0x0073 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_RATED_VOLTAGE_ATTRIBUTE_ID 0x0074 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_ALARM_MASK_ATTRIBUTE_ID 0x0075 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0076 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0077 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0078 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0079 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x007A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x007B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x007C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x007D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_ALARM_STATE_ATTRIBUTE_ID 0x007E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_POWER_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POWER_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Device Temperature Configuration +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_DEVICE_TEMP_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEVICE_TEMP_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CURRENT_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MIN_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAX_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OVER_TEMP_TOTAL_DWELL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DEVICE_TEMP_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_LOW_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_HIGH_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_LOW_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_HIGH_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_DEVICE_TEMP_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEVICE_TEMP_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Identify +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_IDENTIFY_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IDENTIFY_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_IDENTIFY_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COMMISSION_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_IDENTIFY_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IDENTIFY_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Groups +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_GROUPS_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GROUPS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_GROUP_NAME_SUPPORT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_GROUPS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GROUPS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Scenes +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_SCENES_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SCENES_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SCENE_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_SCENE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_GROUP_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SCENE_VALID_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SCENE_NAME_SUPPORT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_LAST_CONFIGURED_BY_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_SCENES_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SCENES_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: On/off +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_ON_OFF_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ON_OFF_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ON_OFF_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_2_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_3_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_4_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_TIME_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_OFF_WAIT_TIME_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_START_UP_ON_OFF_ATTRIBUTE_ID 0x4003 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_ON_OFF_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ON_OFF_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: On/off Switch Configuration +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SWITCH_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SWITCH_ACTIONS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Level Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_LEVEL_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_LEVEL_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CURRENT_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LEVEL_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ON_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_ON_TRANSITION_TIME_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DEFAULT_MOVE_RATE_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_START_UP_CURRENT_LEVEL_ATTRIBUTE_ID 0x4000 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_LEVEL_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_LEVEL_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Alarms +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_ALARM_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ALARM_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ALARM_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ALARM_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ALARM_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Time +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_TIME_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TIME_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TIME_STATUS_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TIME_ZONE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DST_START_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DST_END_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DST_SHIFT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_STANDARD_TIME_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_LOCAL_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_LAST_SET_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_VALID_UNTIL_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_TIME_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TIME_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: RSSI Location +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_RSSI_LOCATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_RSSI_LOCATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LOCATION_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOCATION_METHOD_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LOCATION_AGE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_QUALITY_MEASURE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_DEVICES_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_COORDINATE1_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COORDINATE2_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_COORDINATE3_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_POWER_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PATH_LOSS_EXPONENT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_REPORTING_PERIOD_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_CALCULATION_PERIOD_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_NUMBER_RSSI_MEASUREMENTS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_RSSI_LOCATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_RSSI_LOCATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Binary Input (Basic) +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ACTIVE_TEXT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DESCRIPTION_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_INACTIVE_TEXT_ATTRIBUTE_ID 0x002E // Ver.: always +#define ZCL_OUT_OF_SERVICE_ATTRIBUTE_ID 0x0051 // Ver.: always +#define ZCL_POLARITY_ATTRIBUTE_ID 0x0054 // Ver.: always +#define ZCL_PRESENT_VALUE_ATTRIBUTE_ID 0x0055 // Ver.: always +#define ZCL_RELIABILITY_ATTRIBUTE_ID 0x0067 // Ver.: always +#define ZCL_STATUS_FLAGS_ATTRIBUTE_ID 0x006F // Ver.: always +#define ZCL_APPLICATION_TYPE_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Commissioning +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COMMISSIONING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SHORT_ADDRESS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_EXTENDED_PAN_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PAN_ID_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PROTOCOL_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_STACK_PROFILE_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_STARTUP_CONTROL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_TRUST_CENTER_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_TRUST_CENTER_MASTER_KEY_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_NETWORK_KEY_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_USE_INSECURE_JOIN_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PRECONFIGURED_LINK_KEY_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_NETWORK_KEY_SEQUENCE_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_NETWORK_KEY_TYPE_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_NETWORK_MANAGER_ADDRESS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_SCAN_ATTEMPTS_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_TIME_BETWEEN_SCANS_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_MAX_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0023 // Ver.: always +#define ZCL_INDIRECT_POLL_RATE_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_PARENT_RETRY_THRESHOLD_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_CONCENTRATOR_FLAG_ATTRIBUTE_ID 0x0040 // Ver.: always +#define ZCL_CONCENTRATOR_RADIUS_ATTRIBUTE_ID 0x0041 // Ver.: always +#define ZCL_CONCENTRATOR_DISCOVERY_TIME_ATTRIBUTE_ID 0x0042 // Ver.: always +#define ZCL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COMMISSIONING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Partition +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_PARTITION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PARTITION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PARTITION_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PARTITION_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PARTIONED_FRAME_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_LARGE_FRAME_SIZE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_ACK_FRAME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_NACK_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_INTERFRAME_DELAY_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_NUMBER_OF_SEND_RETRIES_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_SENDER_TIMEOUT_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_RECEIVER_TIMEOUT_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_PARTITION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PARTITION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Over the Air Bootloading +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_UPGRADE_SERVER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FILE_OFFSET_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_FILE_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DOWNLOADED_FILE_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DOWNLOADED_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_IMAGE_UPGRADE_STATUS_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_MANUFACTURER_ID_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_IMAGE_TYPE_ID_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_MINIMUM_BLOCK_REQUEST_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_IMAGE_STAMP_ATTRIBUTE_ID 0x000A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UPGRADE_ACTIVATION_POLICY_ATTRIBUTE_ID 0x000B // Ver.: since se-1.2b-15-0131-02 +#define ZCL_UPGRADE_TIMEOUT_POLICY_ATTRIBUTE_ID 0x000C // Ver.: since se-1.2b-15-0131-02 +#define ZCL_OTA_BOOTLOAD_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OTA_BOOTLOAD_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_OTA_BOOTLOAD_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OTA_BOOTLOAD_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Power Profile +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_POWER_PROFILE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POWER_PROFILE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TOTAL_PROFILE_NUM_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MULTIPLE_SCHEDULING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ENERGY_FORMATTING_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ENERGY_REMOTE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SCHEDULE_MODE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_POWER_PROFILE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POWER_PROFILE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Appliance Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_APPLIANCE_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_START_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FINISH_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_APPLIANCE_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Poll Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_POLL_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POLL_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CHECK_IN_INTERVAL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LONG_POLL_INTERVAL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SHORT_POLL_INTERVAL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FAST_POLL_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHECK_IN_INTERVAL_MIN_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_LONG_POLL_INTERVAL_MIN_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_FAST_POLL_TIMEOUT_MAX_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_POLL_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_POLL_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Green Power +// Cluster specification level: gp-1.0a-09-5499-26 + +// Client attributes +#define ZCL_GP_CLIENT_GPP_MAX_PROXY_TABLE_ENTRIES_ATTRIBUTE_ID 0x0010 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_PROXY_TABLE_ATTRIBUTE_ID 0x0011 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_NUMBER_ATTRIBUTE_ID 0x0012 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_TIMER_ATTRIBUTE_ID 0x0013 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_MAX_SEARCH_COUNTER_ATTRIBUTE_ID 0x0014 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_BLOCKED_GPD_ID_ATTRIBUTE_ID 0x0015 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_FUNCTIONALITY_ATTRIBUTE_ID 0x0016 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0017 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GREEN_POWER_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GREEN_POWER_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_GP_SERVER_GPS_MAX_SINK_TABLE_ENTRIES_ATTRIBUTE_ID 0x0000 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_SINK_TABLE_ATTRIBUTE_ID 0x0001 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMUNICATION_MODE_ATTRIBUTE_ID 0x0002 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMISSIONING_EXIT_MODE_ATTRIBUTE_ID 0x0003 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMISSIONING_WINDOW_ATTRIBUTE_ID 0x0004 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_SECURITY_LEVEL_ATTRIBUTE_ID 0x0005 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_FUNCTIONALITY_ATTRIBUTE_ID 0x0006 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0007 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GREEN_POWER_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GREEN_POWER_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Keep-Alive +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_KEEPALIVE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_KEEPALIVE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_KEEPALIVE_BASE_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2b-15-0131-02 +#define ZCL_KEEPALIVE_JITTER_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2b-15-0131-02 +#define ZCL_KEEPALIVE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_KEEPALIVE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Shade Configuration +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_SHADE_CONFIG_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SHADE_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SHADE_CONFIG_PHYSICAL_CLOSED_LIMIT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SHADE_CONFIG_MOTOR_STEP_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SHADE_CONFIG_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SHADE_CONFIG_CLOSED_LIMIT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SHADE_CONFIG_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SHADE_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SHADE_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Door Lock +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_DOOR_LOCK_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DOOR_LOCK_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LOCK_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOCK_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ACTUATOR_ENABLED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DOOR_STATE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DOOR_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DOOR_CLOSED_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_OPEN_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_NUM_LOCK_RECORDS_SUPPORTED_ATTRIBUTE_ID 0x0010 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID 0x0011 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_PIN_USERS_SUPPORTED_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_RFID_USERS_SUPPORTED_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_WEEKDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_YEARDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0015 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_HOLIDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0016 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MAX_PIN_LENGTH_ATTRIBUTE_ID 0x0017 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MIN_PIN_LENGTH_ATTRIBUTE_ID 0x0018 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MAX_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x0019 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MIN_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x001A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_LOGGING_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LANGUAGE_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LED_SETTINGS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AUTO_RELOCK_TIME_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SOUND_VOLUME_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OPERATING_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID 0x0026 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID 0x0027 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID 0x0028 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_INSIDE_STATUS_LED_ATTRIBUTE_ID 0x002A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID 0x002B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SEND_PIN_OVER_THE_AIR_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_REQUIRE_PIN_FOR_RF_OPERATION_ATTRIBUTE_ID 0x0033 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ZIGBEE_SECURITY_LEVEL_ATTRIBUTE_ID 0x0034 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DOOR_LOCK_ALARM_MASK_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_KEYPAD_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RF_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MANUAL_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RFID_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_KEYPAD_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RF_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RFID_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DOOR_LOCK_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DOOR_LOCK_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Window Covering +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_WINDOW_COVERING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_WINDOW_COVERING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_COVERING_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LIMIT_LIFT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LIMIT_TILT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_LIFT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CURRENT_TILT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_NUMBER_LIFT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_NUMBER_TILT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_CONFIG_STATUS_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_CURRENT_LIFT_PERCENTAGE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_CURRENT_TILT_PERCENTAGE_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_OPEN_LIMIT_LIFT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_OPEN_LIMIT_TILT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_VELOCITY_LIFT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_ACCELERATION_LIFT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_DECELERATION_LIFT_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MODE_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_SETPOINTS_LIFT_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_SETPOINTS_TILT_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_WINDOW_COVERING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_WINDOW_COVERING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Barrier Control +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_BARRIER_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BARRIER_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BARRIER_MOVING_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BARRIER_SAFETY_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BARRIER_CAPABILITIES_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BARRIER_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_BARRIER_OPEN_PERIOD_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_BARRIER_POSITION_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_BARRIER_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BARRIER_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Pump Configuration and Control +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MAX_PRESSURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAX_SPEED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAX_FLOW_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MIN_CONST_PRESSURE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MAX_CONST_PRESSURE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MIN_COMP_PRESSURE_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_MAX_COMP_PRESSURE_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_MIN_CONST_SPEED_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_MAX_CONST_SPEED_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_MIN_CONST_FLOW_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_MAX_CONST_FLOW_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_MIN_CONST_TEMP_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_MAX_CONST_TEMP_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_PUMP_STATUS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CAPACITY_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_SPEED_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_PUMP_POWER_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_OPERATION_MODE_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_CONTROL_MODE_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_PUMP_ALARM_MASK_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Thermostat +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_THERMOSTAT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_THERMOSTAT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LOCAL_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OUTDOOR_TEMPERATURE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_THERMOSTAT_OCCUPANCY_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_PI_COOLING_DEMAND_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_PI_HEATING_DEMAND_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_HVAC_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_REMOTE_SENSING_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_SYSTEM_MODE_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_THERMOSTAT_ALARM_MASK_ATTRIBUTE_ID 0x001D // Ver.: always +#define ZCL_THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID 0x001E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_START_OF_WEEK_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OCCUPIED_SETBACK_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_ATTRIBUTE_ID 0x0037 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0038 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0039 // Ver.: always +#define ZCL_EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID 0x003A // Ver.: always +#define ZCL_AC_TYPE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_CAPACITY_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_REFRIGERANT_TYPE_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_COMPRESSOR_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_ERROR_CODE_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_LOUVER_POSITION_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_COIL_TEMPERATURE_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_CAPACITY_FORMAT_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_THERMOSTAT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_THERMOSTAT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Fan Control +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_FAN_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FAN_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_FAN_CONTROL_FAN_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FAN_CONTROL_FAN_MODE_SEQUENCE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FAN_DELAY_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FAN_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FAN_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Dehumidification Control +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_DEHUMID_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEHUMID_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_RELATIVE_HUMIDITY_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DEHUMIDIFICATION_COOLING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_RH_DEHUMIDIFICATION_SETPOINT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_DEHUMIDIFICATION_LOCKOUT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_DEHUMIDIFICATION_HYSTERESIS_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_DEHUMIDIFICATION_MAX_COOL_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_DISPLAY_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_DEHUMID_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEHUMID_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Thermostat User Interface Configuration +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEYPAD_LOCKOUT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID 0x0002 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BACKLIGHT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SETPOINT_SOURCE_INDICATION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Color Control +// Cluster specification level: zcl6-errata-14-0129-15 + +// Client attributes +#define ZCL_COLOR_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COLOR_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_SATURATION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COLOR_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_X_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_Y_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_COLOR_CONTROL_DRIFT_COMPENSATION_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_COLOR_CONTROL_COMPENSATION_TEXT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_TEMPERATURE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_MODE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_COLOR_CONTROL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COLOR_CONTROL_NUMBER_OF_PRIMARIES_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_X_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_Y_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_INTENSITY_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_X_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_Y_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_INTENSITY_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_X_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_Y_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_INTENSITY_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_X_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_Y_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_INTENSITY_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_X_ATTRIBUTE_ID 0x0024 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_Y_ATTRIBUTE_ID 0x0025 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_INTENSITY_ATTRIBUTE_ID 0x0026 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_X_ATTRIBUTE_ID 0x0028 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_Y_ATTRIBUTE_ID 0x0029 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_INTENSITY_ATTRIBUTE_ID 0x002A // Ver.: always +#define ZCL_COLOR_CONTROL_WHITE_POINT_X_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_COLOR_CONTROL_WHITE_POINT_Y_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_X_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_Y_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_X_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_Y_ATTRIBUTE_ID 0x0037 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID 0x0038 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_X_ATTRIBUTE_ID 0x003A // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_Y_ATTRIBUTE_ID 0x003B // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID 0x003C // Ver.: always +#define ZCL_COLOR_CONTROL_ENHANCED_CURRENT_HUE_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_ENHANCED_COLOR_MODE_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_ACTIVE_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_DIRECTION_ATTRIBUTE_ID 0x4003 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_TIME_ATTRIBUTE_ID 0x4004 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID 0x4005 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID 0x4006 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_CAPABILITIES_ATTRIBUTE_ID 0x400A // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_ATTRIBUTE_ID 0x400B // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_ATTRIBUTE_ID 0x400C // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_TEMPERATURE_LEVEL_MIN_MIREDS_ATTRIBUTE_ID 0x400D // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID 0x4010 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_COLOR_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COLOR_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Ballast Configuration +// Cluster specification level: zcl6-errata-14-0129-15 + +// Client attributes +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BALLAST_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MIN_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_MAX_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_POWER_ON_LEVEL_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_POWER_ON_FADE_TIME_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_LAMP_QUALITY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_LAMP_TYPE_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_LAMP_MANUFACTURER_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_LAMP_RATED_HOURS_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_LAMP_BURN_HOURS_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_LAMP_ALARM_MODE_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Illuminance Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ILLUM_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ILLUM_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ILLUM_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ILLUM_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Illuminance Level Sensing +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LEVEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SENSING_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ILLUMINANCE_TARGET_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Temperature Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_TEMP_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TEMP_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TEMP_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TEMP_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TEMP_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TEMP_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TEMP_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TEMP_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Pressure Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PRESSURE_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PRESSURE_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PRESSURE_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PRESSURE_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PRESSURE_SCALED_VALUE_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PRESSURE_MIN_SCALED_VALUE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_PRESSURE_MAX_SCALED_VALUE_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_PRESSURE_SCALED_TOLERANCE_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PRESSURE_SCALE_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Flow Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_FLOW_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLOW_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_FLOW_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FLOW_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FLOW_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FLOW_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FLOW_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLOW_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Relative Humidity Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_RELATIVE_HUMIDITY_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Occupancy Sensing +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_OCCUPANCY_SENSING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OCCUPANCY_SENSING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_OCCUPANCY_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_OCCUPANCY_SENSING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OCCUPANCY_SENSING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Carbon Monoxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Carbon Dioxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Ethylene Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Ethylene Oxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Hydrogen Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Hydrogen Sulphide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Nitric Oxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Nitrogen Dioxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Oxygen Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Ozone Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sulfur Dioxide Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Dissolved Oxygen Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Bromate Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Chloramines Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Chlorine Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Fecal coliform and E. Coli Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Fluoride Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Haloacetic Acids Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Total Trihalomethanes Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Total Coliform Bacteria Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Turbidity Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Copper Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Lead Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Manganese Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sulfate Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Bromodichloromethane Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Bromoform Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Chlorodibromomethane Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Chloroform Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sodium Concentration Measurement +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: IAS Zone +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_IAS_ZONE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_ZONE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ZONE_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ZONE_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ZONE_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_IAS_CIE_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ZONE_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CURRENT_ZONE_SENSITIVITY_LEVEL_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_IAS_ZONE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_ZONE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: IAS ACE +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_IAS_ACE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_ACE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_IAS_ACE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_ACE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: IAS WD +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client attributes +#define ZCL_IAS_WD_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_WD_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MAX_DURATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_IAS_WD_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_WD_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Generic Tunnel +// Cluster specification level: cba-1.0-05-3516-12 + +// Client attributes +#define ZCL_GENERIC_TUNNEL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GENERIC_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PROTOCOL_ADDRESS_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_GENERIC_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GENERIC_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: BACnet Protocol Tunnel +// Cluster specification level: cba-1.0-05-3516-12 + +// Client attributes +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: 11073 Protocol Tunnel +// Cluster specification level: hc-1.0-07-5360-15 + +// Client attributes +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_DEVICE_ID_LIST_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MANAGER_TARGET_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MANAGER_ENDPOINT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CONNECTED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PREEMPTIBLE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_IDLE_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: ISO 7816 Protocol Tunnel +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ISO7816_PROTOCOL_TUNNEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Price +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_PRICE_INCREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PRICE_DECREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COMMODITY_TYPE_CLIENT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PRICE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PRICE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x000F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x001A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x001B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x001C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x0023 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x0024 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x0025 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x0026 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x0027 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x0028 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x0029 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x002A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x002B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x002C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x002D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x002E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x002F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x010E // Ver.: always +#define ZCL_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x010F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x011A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x011B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x011C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x011D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0160 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0161 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0162 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0163 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0164 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0165 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0166 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0167 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0168 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0169 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x016A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x016B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x016C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x016D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x016E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x016F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0170 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0171 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0172 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0173 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0174 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0175 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0176 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0177 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0178 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0179 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x017A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x017B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x017C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x017D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x017E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x017F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0180 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0181 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0182 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0183 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0184 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0185 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0186 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0187 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0188 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0189 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x018A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x018B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x018C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x018D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x018E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x018F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0190 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0191 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0192 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0193 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0194 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0195 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0196 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0197 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0198 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0199 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x019A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x019B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x019C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x019D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x019E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x019F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_BLOCK_PERIOD_DURATION_MINUTES_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_BLOCK_PERIOD_DURATION_TYPE_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_COMMODITY_TYPE_SERVER_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_STANDING_CHARGE_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_CONVERSION_FACTOR_ATTRIBUTE_ID 0x0302 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CONVERSION_FACTOR_TRAILING_DIGIT_ATTRIBUTE_ID 0x0303 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_ATTRIBUTE_ID 0x0304 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_UNIT_ATTRIBUTE_ID 0x0305 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0306 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x0406 // Ver.: always +#define ZCL_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x0407 // Ver.: always +#define ZCL_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x0408 // Ver.: always +#define ZCL_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x0409 // Ver.: always +#define ZCL_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x040A // Ver.: always +#define ZCL_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x040B // Ver.: always +#define ZCL_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x040C // Ver.: always +#define ZCL_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x040D // Ver.: always +#define ZCL_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x040E // Ver.: always +#define ZCL_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x040F // Ver.: always +#define ZCL_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x0410 // Ver.: always +#define ZCL_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x0411 // Ver.: always +#define ZCL_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x0412 // Ver.: always +#define ZCL_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x0413 // Ver.: always +#define ZCL_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x0414 // Ver.: always +#define ZCL_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x0415 // Ver.: always +#define ZCL_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x0416 // Ver.: always +#define ZCL_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x0417 // Ver.: always +#define ZCL_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x0418 // Ver.: always +#define ZCL_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x0419 // Ver.: always +#define ZCL_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x041A // Ver.: always +#define ZCL_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x041B // Ver.: always +#define ZCL_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x041C // Ver.: always +#define ZCL_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x041D // Ver.: always +#define ZCL_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x041E // Ver.: always +#define ZCL_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x041F // Ver.: always +#define ZCL_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x0420 // Ver.: always +#define ZCL_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x0421 // Ver.: always +#define ZCL_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x0422 // Ver.: always +#define ZCL_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x0423 // Ver.: always +#define ZCL_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x0424 // Ver.: always +#define ZCL_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x0425 // Ver.: always +#define ZCL_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x0426 // Ver.: always +#define ZCL_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x0427 // Ver.: always +#define ZCL_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x0428 // Ver.: always +#define ZCL_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x0429 // Ver.: always +#define ZCL_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x042A // Ver.: always +#define ZCL_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x042B // Ver.: always +#define ZCL_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x042C // Ver.: always +#define ZCL_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x042D // Ver.: always +#define ZCL_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x042E // Ver.: always +#define ZCL_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x042F // Ver.: always +#define ZCL_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x0430 // Ver.: always +#define ZCL_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x0431 // Ver.: always +#define ZCL_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x0432 // Ver.: always +#define ZCL_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x0433 // Ver.: always +#define ZCL_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x0434 // Ver.: always +#define ZCL_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x0435 // Ver.: always +#define ZCL_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x0436 // Ver.: always +#define ZCL_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x0437 // Ver.: always +#define ZCL_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x0438 // Ver.: always +#define ZCL_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x0439 // Ver.: always +#define ZCL_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x043A // Ver.: always +#define ZCL_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x043B // Ver.: always +#define ZCL_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x043C // Ver.: always +#define ZCL_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x043D // Ver.: always +#define ZCL_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x043E // Ver.: always +#define ZCL_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x043F // Ver.: always +#define ZCL_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x0440 // Ver.: always +#define ZCL_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x0441 // Ver.: always +#define ZCL_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x0442 // Ver.: always +#define ZCL_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x0443 // Ver.: always +#define ZCL_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x0444 // Ver.: always +#define ZCL_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x0445 // Ver.: always +#define ZCL_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x0446 // Ver.: always +#define ZCL_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x0447 // Ver.: always +#define ZCL_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x0448 // Ver.: always +#define ZCL_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x0449 // Ver.: always +#define ZCL_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x044A // Ver.: always +#define ZCL_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x044B // Ver.: always +#define ZCL_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x044C // Ver.: always +#define ZCL_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x044D // Ver.: always +#define ZCL_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x044E // Ver.: always +#define ZCL_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x044F // Ver.: always +#define ZCL_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x0450 // Ver.: always +#define ZCL_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x0451 // Ver.: always +#define ZCL_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x0452 // Ver.: always +#define ZCL_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x0453 // Ver.: always +#define ZCL_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x0454 // Ver.: always +#define ZCL_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x0455 // Ver.: always +#define ZCL_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x0456 // Ver.: always +#define ZCL_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x0457 // Ver.: always +#define ZCL_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x0458 // Ver.: always +#define ZCL_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x0459 // Ver.: always +#define ZCL_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x045A // Ver.: always +#define ZCL_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x045B // Ver.: always +#define ZCL_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x045C // Ver.: always +#define ZCL_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x045D // Ver.: always +#define ZCL_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x045E // Ver.: always +#define ZCL_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x045F // Ver.: always +#define ZCL_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x0460 // Ver.: always +#define ZCL_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x0461 // Ver.: always +#define ZCL_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x0462 // Ver.: always +#define ZCL_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x0463 // Ver.: always +#define ZCL_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x0464 // Ver.: always +#define ZCL_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x0465 // Ver.: always +#define ZCL_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x0466 // Ver.: always +#define ZCL_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x0467 // Ver.: always +#define ZCL_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x0468 // Ver.: always +#define ZCL_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x0469 // Ver.: always +#define ZCL_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x046A // Ver.: always +#define ZCL_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x046B // Ver.: always +#define ZCL_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x046C // Ver.: always +#define ZCL_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x046D // Ver.: always +#define ZCL_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x046E // Ver.: always +#define ZCL_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x046F // Ver.: always +#define ZCL_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x0470 // Ver.: always +#define ZCL_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x0471 // Ver.: always +#define ZCL_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x0472 // Ver.: always +#define ZCL_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x0473 // Ver.: always +#define ZCL_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x0474 // Ver.: always +#define ZCL_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x0475 // Ver.: always +#define ZCL_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x0476 // Ver.: always +#define ZCL_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x0477 // Ver.: always +#define ZCL_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x0478 // Ver.: always +#define ZCL_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x0479 // Ver.: always +#define ZCL_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x047A // Ver.: always +#define ZCL_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x047B // Ver.: always +#define ZCL_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x047C // Ver.: always +#define ZCL_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x047D // Ver.: always +#define ZCL_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x047E // Ver.: always +#define ZCL_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x047F // Ver.: always +#define ZCL_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x0480 // Ver.: always +#define ZCL_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x0481 // Ver.: always +#define ZCL_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x0482 // Ver.: always +#define ZCL_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x0483 // Ver.: always +#define ZCL_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x0484 // Ver.: always +#define ZCL_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x0485 // Ver.: always +#define ZCL_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x0486 // Ver.: always +#define ZCL_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x0487 // Ver.: always +#define ZCL_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x0488 // Ver.: always +#define ZCL_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x0489 // Ver.: always +#define ZCL_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x048A // Ver.: always +#define ZCL_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x048B // Ver.: always +#define ZCL_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x048C // Ver.: always +#define ZCL_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x048D // Ver.: always +#define ZCL_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x048E // Ver.: always +#define ZCL_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x048F // Ver.: always +#define ZCL_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x0490 // Ver.: always +#define ZCL_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x0491 // Ver.: always +#define ZCL_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x0492 // Ver.: always +#define ZCL_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x0493 // Ver.: always +#define ZCL_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x0494 // Ver.: always +#define ZCL_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x0495 // Ver.: always +#define ZCL_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x0496 // Ver.: always +#define ZCL_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x0497 // Ver.: always +#define ZCL_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x0498 // Ver.: always +#define ZCL_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x0499 // Ver.: always +#define ZCL_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x049A // Ver.: always +#define ZCL_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x049B // Ver.: always +#define ZCL_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x049C // Ver.: always +#define ZCL_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x049D // Ver.: always +#define ZCL_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x049E // Ver.: always +#define ZCL_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x049F // Ver.: always +#define ZCL_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x04A0 // Ver.: always +#define ZCL_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x04A1 // Ver.: always +#define ZCL_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x04A2 // Ver.: always +#define ZCL_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x04A3 // Ver.: always +#define ZCL_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x04A4 // Ver.: always +#define ZCL_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x04A5 // Ver.: always +#define ZCL_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x04A6 // Ver.: always +#define ZCL_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x04A7 // Ver.: always +#define ZCL_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x04A8 // Ver.: always +#define ZCL_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x04A9 // Ver.: always +#define ZCL_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x04AA // Ver.: always +#define ZCL_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x04AB // Ver.: always +#define ZCL_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x04AC // Ver.: always +#define ZCL_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x04AD // Ver.: always +#define ZCL_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x04AE // Ver.: always +#define ZCL_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x04AF // Ver.: always +#define ZCL_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x04B0 // Ver.: always +#define ZCL_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x04B1 // Ver.: always +#define ZCL_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x04B2 // Ver.: always +#define ZCL_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x04B3 // Ver.: always +#define ZCL_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x04B4 // Ver.: always +#define ZCL_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x04B5 // Ver.: always +#define ZCL_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x04B6 // Ver.: always +#define ZCL_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x04B7 // Ver.: always +#define ZCL_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x04B8 // Ver.: always +#define ZCL_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x04B9 // Ver.: always +#define ZCL_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x04BA // Ver.: always +#define ZCL_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x04BB // Ver.: always +#define ZCL_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x04BC // Ver.: always +#define ZCL_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x04BD // Ver.: always +#define ZCL_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x04BE // Ver.: always +#define ZCL_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x04BF // Ver.: always +#define ZCL_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x04C0 // Ver.: always +#define ZCL_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x04C1 // Ver.: always +#define ZCL_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x04C2 // Ver.: always +#define ZCL_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x04C3 // Ver.: always +#define ZCL_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x04C4 // Ver.: always +#define ZCL_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x04C5 // Ver.: always +#define ZCL_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x04C6 // Ver.: always +#define ZCL_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x04C7 // Ver.: always +#define ZCL_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x04C8 // Ver.: always +#define ZCL_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x04C9 // Ver.: always +#define ZCL_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x04CA // Ver.: always +#define ZCL_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x04CB // Ver.: always +#define ZCL_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x04CC // Ver.: always +#define ZCL_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x04CD // Ver.: always +#define ZCL_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x04CE // Ver.: always +#define ZCL_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x04CF // Ver.: always +#define ZCL_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x04D0 // Ver.: always +#define ZCL_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x04D1 // Ver.: always +#define ZCL_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x04D2 // Ver.: always +#define ZCL_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x04D3 // Ver.: always +#define ZCL_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x04D4 // Ver.: always +#define ZCL_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x04D5 // Ver.: always +#define ZCL_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x04D6 // Ver.: always +#define ZCL_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x04D7 // Ver.: always +#define ZCL_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x04D8 // Ver.: always +#define ZCL_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x04D9 // Ver.: always +#define ZCL_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x04DA // Ver.: always +#define ZCL_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x04DB // Ver.: always +#define ZCL_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x04DC // Ver.: always +#define ZCL_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x04DD // Ver.: always +#define ZCL_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x04DE // Ver.: always +#define ZCL_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x04DF // Ver.: always +#define ZCL_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x04E0 // Ver.: always +#define ZCL_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x04E1 // Ver.: always +#define ZCL_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x04E2 // Ver.: always +#define ZCL_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x04E3 // Ver.: always +#define ZCL_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x04E4 // Ver.: always +#define ZCL_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x04E5 // Ver.: always +#define ZCL_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x04E6 // Ver.: always +#define ZCL_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x04E7 // Ver.: always +#define ZCL_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x04E8 // Ver.: always +#define ZCL_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x04E9 // Ver.: always +#define ZCL_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x04EA // Ver.: always +#define ZCL_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x04EB // Ver.: always +#define ZCL_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x04EC // Ver.: always +#define ZCL_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x04ED // Ver.: always +#define ZCL_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x04EE // Ver.: always +#define ZCL_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x04EF // Ver.: always +#define ZCL_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x04F0 // Ver.: always +#define ZCL_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x04F1 // Ver.: always +#define ZCL_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x04F2 // Ver.: always +#define ZCL_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x04F3 // Ver.: always +#define ZCL_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x04F4 // Ver.: always +#define ZCL_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x04F5 // Ver.: always +#define ZCL_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x04F6 // Ver.: always +#define ZCL_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x04F7 // Ver.: always +#define ZCL_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x04F8 // Ver.: always +#define ZCL_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x04F9 // Ver.: always +#define ZCL_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x04FA // Ver.: always +#define ZCL_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x04FB // Ver.: always +#define ZCL_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x04FC // Ver.: always +#define ZCL_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x04FD // Ver.: always +#define ZCL_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x04FE // Ver.: always +#define ZCL_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x04FF // Ver.: always +#define ZCL_PRICE_TIER16_ATTRIBUTE_ID 0x050F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER17_ATTRIBUTE_ID 0x0510 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER18_ATTRIBUTE_ID 0x0511 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER19_ATTRIBUTE_ID 0x0512 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER20_ATTRIBUTE_ID 0x0513 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER21_ATTRIBUTE_ID 0x0514 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER22_ATTRIBUTE_ID 0x0515 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER23_ATTRIBUTE_ID 0x0516 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER24_ATTRIBUTE_ID 0x0517 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER25_ATTRIBUTE_ID 0x0518 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER26_ATTRIBUTE_ID 0x0519 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER27_ATTRIBUTE_ID 0x051A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER28_ATTRIBUTE_ID 0x051B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER29_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER30_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER31_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER32_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER33_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER34_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER35_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER36_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER37_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER38_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER39_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER40_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER41_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER42_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER43_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER44_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER45_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER46_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER47_ATTRIBUTE_ID 0x052E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER48_ATTRIBUTE_ID 0x052F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP1_PRICE_ATTRIBUTE_ID 0x05FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP2_PRICE_ATTRIBUTE_ID 0x05FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_LABEL_ATTRIBUTE_ID 0x0610 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x0611 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x0612 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x0613 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0615 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CURRENCY_ATTRIBUTE_ID 0x0616 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0617 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x0619 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_ATTRIBUTE_ID 0x0620 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_UNIT_ATTRIBUTE_ID 0x0621 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x0622 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1b-07-5356-18 +#define ZCL_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1b-07-5356-18 +#define ZCL_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BILLING_PERIOD_CONSOLIDATED_BILL_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DUE_DATE_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_STATUS_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_OVER_DUE_AMOUNT_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PAYMENT_DISCOUNT_ATTRIBUTE_ID 0x080A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PAYMENT_DISCOUNT_PERIOD_ATTRIBUTE_ID 0x080B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_1_ATTRIBUTE_ID 0x0810 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_1_ATTRIBUTE_ID 0x0811 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_1_ATTRIBUTE_ID 0x0812 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_2_ATTRIBUTE_ID 0x0820 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_2_ATTRIBUTE_ID 0x0821 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_2_ATTRIBUTE_ID 0x0822 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_3_ATTRIBUTE_ID 0x0830 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_3_ATTRIBUTE_ID 0x0831 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_3_ATTRIBUTE_ID 0x0832 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_4_ATTRIBUTE_ID 0x0840 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_4_ATTRIBUTE_ID 0x0841 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_4_ATTRIBUTE_ID 0x0842 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_5_ATTRIBUTE_ID 0x0850 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_5_ATTRIBUTE_ID 0x0851 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_5_ATTRIBUTE_ID 0x0852 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x8000 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x8001 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x8002 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x8003 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x8004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x8005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x8006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x8007 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x8008 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x8009 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x800A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x800B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x800C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x800D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x800E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x800F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x8010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x8011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x8012 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x8013 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x8014 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x8015 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x8016 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x8017 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x8018 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x8019 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x801A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x801B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x801C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x801D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x801E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x801F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x8020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x8021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x8022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x8023 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x8024 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x8025 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x8026 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x8027 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x8028 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x8029 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x802A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x802B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x802C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x802D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x802E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x802F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x8100 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x8101 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x8102 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x8103 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x8104 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x8105 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x8106 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x8107 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x8108 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x8109 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x810A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x810B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x810C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x810D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x810E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x8200 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK_PERIOD_DURATION_ATTRIBUTE_ID 0x8201 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x8202 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x8203 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x8400 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x8401 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x8402 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x8403 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x8404 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x8405 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x8406 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x8407 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x8408 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x8409 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x840A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x840B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x840C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x840D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x840E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x840F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x8410 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x8411 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x8412 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x8413 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x8414 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x8415 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x8416 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x8417 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x8418 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x8419 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x841A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x841B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x841C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x841D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x841E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x841F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x8420 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x8421 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x8422 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x8423 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x8424 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x8425 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x8426 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x8427 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x8428 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x8429 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x842A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x842B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x842C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x842D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x842E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x842F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x8430 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x8431 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x8432 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x8433 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x8434 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x8435 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x8436 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x8437 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x8438 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x8439 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x843A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x843B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x843C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x843D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x843E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x843F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x8440 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x8441 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x8442 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x8443 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x8444 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x8445 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x8446 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x8447 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x8448 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x8449 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x844A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x844B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x844C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x844D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x844E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x844F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x8450 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x8451 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x8452 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x8453 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x8454 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x8455 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x8456 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x8457 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x8458 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x8459 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x845A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x845B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x845C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x845D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x845E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x845F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x8460 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x8461 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x8462 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x8463 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x8464 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x8465 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x8466 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x8467 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x8468 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x8469 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x846A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x846B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x846C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x846D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x846E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x846F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x8470 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x8471 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x8472 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x8473 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x8474 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x8475 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x8476 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x8477 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x8478 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x8479 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x847A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x847B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x847C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x847D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x847E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x847F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x8480 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x8481 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x8482 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x8483 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x8484 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x8485 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x8486 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x8487 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x8488 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x8489 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x848A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x848B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x848C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x848D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x848E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x848F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x8490 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x8491 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x8492 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x8493 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x8494 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x8495 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x8496 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x8497 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x8498 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x8499 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x849A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x849B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x849C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x849D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x849E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x849F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x84A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x84A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x84A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x84A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x84A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x84A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x84A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x84A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x84A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x84A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x84AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x84AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x84AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x84AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x84AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x84AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x84B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x84B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x84B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x84B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x84B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x84B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x84B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x84B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x84B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x84B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x84BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x84BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x84BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x84BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x84BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x84BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x84C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x84C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x84C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x84C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x84C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x84C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x84C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x84C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x84C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x84C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x84CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x84CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x84CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x84CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x84CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x84CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x84D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x84D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x84D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x84D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x84D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x84D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x84D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x84D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x84D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x84D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x84DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x84DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x84DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x84DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x84DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x84DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x84E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x84E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x84E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x84E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x84E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x84E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x84E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x84E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x84E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x84E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x84EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x84EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x84EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x84ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x84EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x84EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x84F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x84F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x84F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x84F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x84F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x84F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x84F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x84F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x84F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x84F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x84FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x84FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x84FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x84FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x84FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x84FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER16_ATTRIBUTE_ID 0x850F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER17_ATTRIBUTE_ID 0x8510 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER18_ATTRIBUTE_ID 0x8511 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER19_ATTRIBUTE_ID 0x8512 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER20_ATTRIBUTE_ID 0x8513 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER21_ATTRIBUTE_ID 0x8514 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER22_ATTRIBUTE_ID 0x8515 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER23_ATTRIBUTE_ID 0x8516 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER24_ATTRIBUTE_ID 0x8517 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER25_ATTRIBUTE_ID 0x8518 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER26_ATTRIBUTE_ID 0x8519 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER27_ATTRIBUTE_ID 0x851A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER28_ATTRIBUTE_ID 0x851B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER29_ATTRIBUTE_ID 0x851C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER30_ATTRIBUTE_ID 0x851D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER31_ATTRIBUTE_ID 0x851E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER32_ATTRIBUTE_ID 0x851F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER33_ATTRIBUTE_ID 0x8520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER34_ATTRIBUTE_ID 0x8521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER35_ATTRIBUTE_ID 0x8522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER36_ATTRIBUTE_ID 0x8523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER37_ATTRIBUTE_ID 0x8524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER38_ATTRIBUTE_ID 0x8525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER39_ATTRIBUTE_ID 0x8526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER40_ATTRIBUTE_ID 0x8527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER41_ATTRIBUTE_ID 0x8528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER42_ATTRIBUTE_ID 0x8529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER43_ATTRIBUTE_ID 0x852A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER44_ATTRIBUTE_ID 0x852B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER45_ATTRIBUTE_ID 0x852C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER46_ATTRIBUTE_ID 0x852D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER47_ATTRIBUTE_ID 0x852E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER48_ATTRIBUTE_ID 0x852F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TARIFF_LABEL_ATTRIBUTE_ID 0x8610 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x8611 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x8612 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x8613 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x8615 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_ATTRIBUTE_ID 0x8625 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_UNIT_ATTRIBUTE_ID 0x8626 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x8627 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8700 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8701 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8702 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8703 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_LAST_BILLING_PERIOD_CONSOLIDATED_BILL_ATTRIBUTE_ID 0x8704 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PRICE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Demand Response and Load Control +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_UTILITY_ENROLLMENT_GROUP_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_START_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DURATION_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DEVICE_CLASS_VALUE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Simple Metering +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_FUNCTIONAL_NOTIFICATION_FLAGS_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_2_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_3_ATTRIBUTE_ID 0x0002 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_4_ATTRIBUTE_ID 0x0003 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_5_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_6_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_7_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_8_ATTRIBUTE_ID 0x0007 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SIMPLE_METERING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SIMPLE_METERING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CURRENT_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DFT_SUMMATION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DAILY_FREEZE_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_POWER_FACTOR_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_READING_SNAP_SHOT_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_DEFAULT_UPDATE_PERIOD_ATTRIBUTE_ID 0x000A // Ver.: since se-1.1-07-5356-16 +#define ZCL_FAST_POLL_UPDATE_PERIOD_ATTRIBUTE_ID 0x000B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x000C // Ver.: since se-1.1-07-5356-16 +#define ZCL_DAILY_CONSUMPTION_TARGET_ATTRIBUTE_ID 0x000D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_BLOCK_ATTRIBUTE_ID 0x000E // Ver.: since se-1.1-07-5356-16 +#define ZCL_PROFILE_INTERVAL_PERIOD_ATTRIBUTE_ID 0x000F // Ver.: since se-1.1-07-5356-16 +#define ZCL_INTERVAL_READ_REPORTING_PERIOD_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PRESET_READING_TIME_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.1-07-5356-16 +#define ZCL_VOLUME_PER_REPORT_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.1-07-5356-16 +#define ZCL_FLOW_RESTRICTION_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.1-07-5356-16 +#define ZCL_SUPPLY_STATUS_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_INLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.1-07-5356-16 +#define ZCL_INLET_TEMPERATURE_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.1-07-5356-16 +#define ZCL_OUTLET_TEMPERATURE_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CONTROL_TEMPERATURE_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_INLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001B // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_BLOCK_PERIOD_CONSUMIPTION_DELIVERED_ATTRIBUTE_ID 0x001C // Ver.: since se-1.1b-07-5356-18 +#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_BLOCK_RECEIVED_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DFT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACTIVE_REGISTER_TIER_DELIVERED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACTIVE_REGISTER_TIER_RECEIVED_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BLOCK_SWITCH_TIME_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_STATUS_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_REMAINING_BATTERY_LIFE_ATTRIBUTE_ID 0x0201 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HOURS_IN_OPERATION_ATTRIBUTE_ID 0x0202 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HOURS_IN_FAULT_ATTRIBUTE_ID 0x0203 // Ver.: since se-1.1-07-5356-16 +#define ZCL_EXTENDED_STATUS_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_REMAINING_BATTERY_LIFE_IN_DAYS_ATTRIBUTE_ID 0x0205 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_METER_ID_ATTRIBUTE_ID 0x0206 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_AMBIENT_CONSUMPTION_INDICATOR_ATTRIBUTE_ID 0x0207 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_MULTIPLIER_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_DIVISOR_ATTRIBUTE_ID 0x0302 // Ver.: always +#define ZCL_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x0303 // Ver.: always +#define ZCL_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0304 // Ver.: always +#define ZCL_HISTORICAL_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0305 // Ver.: always +#define ZCL_METERING_DEVICE_TYPE_ATTRIBUTE_ID 0x0306 // Ver.: always +#define ZCL_SITE_ID_ATTRIBUTE_ID 0x0307 // Ver.: since se-1.1-07-5356-16 +#define ZCL_METER_SERIAL_NUMBER_ATTRIBUTE_ID 0x0308 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0309 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x030A // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_DEMAND_FORMATTING_ATTRIBUTE_ID 0x030B // Ver.: since se-1.1-07-5356-16 +#define ZCL_TEMPERATURE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x030C // Ver.: since se-1.1-07-5356-16 +#define ZCL_TEMPERATURE_FORMATTING_ATTRIBUTE_ID 0x030D // Ver.: since se-1.1-07-5356-16 +#define ZCL_MODULE_SERIAL_NUMBER_ATTRIBUTE_ID 0x030E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OPERATING_TARIFF_LABEL_DELIVERED_ATTRIBUTE_ID 0x030F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OPERATING_TARIFF_LABEL_RECEIVED_ATTRIBUTE_ID 0x0310 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CUSTOMER_ID_NUMBER_ATTRIBUTE_ID 0x0311 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0312 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0313 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0314 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_CURRENT_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_CURRENT_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_PREVIOUS_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_PREVIOUS_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_DELIVERED_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0406 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0407 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0408 // Ver.: always +#define ZCL_CURRENT_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0409 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040A // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x040B // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040D // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x040F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0410 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0411 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0412 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0413 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0414 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0415 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0416 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0420 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0421 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0422 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0423 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0424 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0425 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0426 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0427 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0428 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0429 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0430 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0431 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0432 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0433 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0434 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0435 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0436 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0437 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0438 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0439 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x043A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x043B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0440 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0441 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0442 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0443 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0444 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0445 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0446 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0447 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0448 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0449 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0450 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0451 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0452 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0453 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0454 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0455 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0456 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0457 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0458 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0459 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x045A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x045B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_METERING_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x045C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x045D // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x045E // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x045F // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0460 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0461 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0462 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0463 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0464 // Ver.: since se-1.4-17-05019-001 +#define ZCL_MAX_NUMBER_OF_PERIODS_DELIVERED_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_CURRENT_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_DEMAND_LIMIT_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_DEMAND_INTEGRATION_PERIOD_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_NUMBER_OF_DEMAND_SUBINTERVALS_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_DEMAND_LIMIT_ARM_DURATION_IN_MINUTES_ATTRIBUTE_ID 0x0604 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOAD_LIMIT_SUPPLY_STATE_ATTRIBUTE_ID 0x0605 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOAD_LIMIT_COUNTER_ATTRIBUTE_ID 0x0606 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_TAMPER_STATE_ATTRIBUTE_ID 0x0607 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_DEPLETION_STATE_ATTRIBUTE_ID 0x0608 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_UNCONTROLLED_FLOW_STATE_ATTRIBUTE_ID 0x0609 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0705 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0706 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0707 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0708 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0709 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0710 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0711 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0712 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0713 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0714 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0715 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0716 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0717 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0718 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0719 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0720 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0721 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0722 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0723 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0724 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0725 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0726 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0727 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0728 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0729 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0730 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0731 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0732 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0733 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0734 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0735 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0736 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0737 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0738 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0739 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0740 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0741 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0742 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0743 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0744 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0745 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0746 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0747 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0748 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0749 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0750 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0751 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0752 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0753 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0754 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0755 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0756 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0757 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0758 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0759 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0760 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0761 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0762 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0763 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0764 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0765 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0766 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0767 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0768 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0769 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0770 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0771 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0772 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0773 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0774 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0775 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0776 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0777 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0778 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0779 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0780 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0781 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0782 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0783 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0784 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0785 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0786 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0787 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0788 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0789 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0790 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0791 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0792 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0793 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0794 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0795 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0796 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0797 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0798 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0799 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07ED // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FF // Ver.: since se-1.1-07-5356-16 +#define ZCL_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ELECTRICITY_ALARM_MASK_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GENERIC_FLOW_PRESSURE_ALARM_MASK_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.1-07-5356-16 +#define ZCL_WATER_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0803 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0804 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GAS_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0805 // Ver.: since se-1.1-07-5356-16 +#define ZCL_METERING_EXTENDED_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0806 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_METERING_MANUFACTURE_ALARM_MASK_ATTRIBUTE_ID 0x0807 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0900 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0901 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0902 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0903 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0904 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0905 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0906 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0907 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0908 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0909 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0910 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0911 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0912 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0913 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0914 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0915 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0916 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0917 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0918 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0919 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0920 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0921 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0922 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0923 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0924 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0925 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0926 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0927 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0928 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0929 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0930 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0931 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0932 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0933 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0934 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0935 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0936 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0937 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0938 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0939 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0940 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0941 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0942 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0943 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0944 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0945 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0946 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0947 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0948 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0949 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0950 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0951 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0952 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0953 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0954 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0955 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0956 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0957 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0958 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0959 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0960 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0961 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0962 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0963 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0964 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0965 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0966 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0967 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0968 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0969 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0970 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0971 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0972 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0973 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0974 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0975 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0976 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0977 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0978 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0979 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0980 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0981 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0982 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0983 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0984 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0985 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0986 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0987 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0988 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0989 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0990 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0991 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0992 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0993 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0994 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0995 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0996 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0997 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0998 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0999 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_DELIVERED_ATTRIBUTE_ID 0x0A00 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_DELIVERED_ATTRIBUTE_ID 0x0A02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_DELIVERED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_RECEIVED_ATTRIBUTE_ID 0x0A10 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A11 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_RECEIVED_ATTRIBUTE_ID 0x0A12 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A13 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_RECEIVED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A14 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROPOSED_CHANGE_SUPPLY_IMPLEMENTATION_TIME_ATTRIBUTE_ID 0x0B00 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROPOSED_CHANGE_SUPPLY_STATUS_ATTRIBUTE_ID 0x0B01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_THESHOLD_ATTRIBUTE_ID 0x0B10 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_THESHOLD_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0B11 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_MULTIPLIER_ATTRIBUTE_ID 0x0B12 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_DIVISOR_ATTRIBUTE_ID 0x0B13 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FLOW_STABILIZATION_PERIOD_ATTRIBUTE_ID 0x0B14 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FLOW_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0B15 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0C00 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C01 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C02 // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C03 // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C04 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_START_TIME_DELIVERED_ATTRIBUTE_ID 0x0C05 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0C06 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0C07 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0C08 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0C09 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0A // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_PRESSURE_ATTRIBUTE_ID 0x0C0B // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0C // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0D // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0E // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x0C0F // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0C10 // Ver.: always +#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C20 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C21 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C22 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C23 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C24 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C25 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C26 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C27 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C28 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C29 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C30 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C31 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C32 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C33 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C34 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C35 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C36 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C37 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C38 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C39 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C3A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C3B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C40 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C41 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C42 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C43 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C44 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C45 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C46 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C47 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C48 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C49 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C50 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C51 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C52 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C53 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C54 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C55 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C56 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C57 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C58 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C59 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C5A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C5B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C5C // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C5D // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C5E // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C5F // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C60 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C61 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C62 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C63 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D01 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D02 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D03 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D04 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D05 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D06 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D07 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D08 // Ver.: since se-1.4-17-05019-001 +#define ZCL_SIMPLE_METERING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SIMPLE_METERING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Messaging +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_MESSAGING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MESSAGING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MESSAGING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MESSAGING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Tunneling +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_TUNNELING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TUNNELING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CLOSE_TUNNEL_TIMEOUT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TUNNELING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TUNNELING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Prepayment +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_PREPAYMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PREPAYMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PAYMENT_CONTROL_CONFIGURATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CREDIT_REMAINING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_REMAINING_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CREDIT_STATUS_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CREDIT_REMAINING_TIMESTAMP_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACCUMULATED_DEBT_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OVERALL_DEBT_CAP_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_LIMIT_ALLOWANCE_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOTAL_CREDIT_ADDED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_MAX_CREDIT_LIMIT_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_MAX_CREDIT_PER_TOP_UP_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FRIENDLY_CREDIT_WARNING_ATTRIBUTE_ID 0x0030 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0031 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0032 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_INTERRUPT_SUSPEND_TIME_ATTRIBUTE_ID 0x0033 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_REMAINING_FRIENDLY_CREDIT_TIME_ATTRIBUTE_ID 0x0034 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NEXT_FRIENDLY_CREDIT_PERIOD_ATTRIBUTE_ID 0x0035 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CUT_OFF_VALUE_ATTRIBUTE_ID 0x0040 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOKEN_CARRIER_ID_ATTRIBUTE_ID 0x0080 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_1_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_1_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_1_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_TOP_UP_CODE_1_ATTRIBUTE_ID 0x0103 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_2_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_2_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_2_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_TOP_UP_CODE_2_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_3_ATTRIBUTE_ID 0x0120 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_3_ATTRIBUTE_ID 0x0121 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_3_ATTRIBUTE_ID 0x0122 // Ver.: always +#define ZCL_TOP_UP_CODE_3_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_4_ATTRIBUTE_ID 0x0130 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_4_ATTRIBUTE_ID 0x0131 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_4_ATTRIBUTE_ID 0x0132 // Ver.: always +#define ZCL_TOP_UP_CODE_4_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_5_ATTRIBUTE_ID 0x0140 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_5_ATTRIBUTE_ID 0x0141 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_5_ATTRIBUTE_ID 0x0142 // Ver.: always +#define ZCL_TOP_UP_CODE_5_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_1_ATTRIBUTE_ID 0x0210 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_1_ATTRIBUTE_ID 0x0211 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_1_ATTRIBUTE_ID 0x0212 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_1_ATTRIBUTE_ID 0x0213 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_1_ATTRIBUTE_ID 0x0214 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_1_ATTRIBUTE_ID 0x0216 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_1_ATTRIBUTE_ID 0x0217 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_1_ATTRIBUTE_ID 0x0219 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_2_ATTRIBUTE_ID 0x0220 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_2_ATTRIBUTE_ID 0x0221 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_2_ATTRIBUTE_ID 0x0222 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_2_ATTRIBUTE_ID 0x0223 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_2_ATTRIBUTE_ID 0x0224 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_2_ATTRIBUTE_ID 0x0226 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_2_ATTRIBUTE_ID 0x0227 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_2_ATTRIBUTE_ID 0x0229 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_3_ATTRIBUTE_ID 0x0230 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_3_ATTRIBUTE_ID 0x0231 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_3_ATTRIBUTE_ID 0x0232 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_3_ATTRIBUTE_ID 0x0233 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_3_ATTRIBUTE_ID 0x0234 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_3_ATTRIBUTE_ID 0x0236 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_3_ATTRIBUTE_ID 0x0237 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_3_ATTRIBUTE_ID 0x0239 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_ALARM_STATUS_ATTRIBUTE_ID 0x0400 // Ver.: since se-1.2a-07-5356-21 +#define ZCL_PREPAY_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0401 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAY_SWITCH_ALARM_MASK_ATTRIBUTE_ID 0x0402 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAY_EVENT_ALARM_MASK_ATTRIBUTE_ID 0x0403 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_HISTORICAL_COST_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0500 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMPTION_UNIT_OF_MEASUREMENT_ATTRIBUTE_ID 0x0501 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENCY_SCALING_FACTOR_ATTRIBUTE_ID 0x0502 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMANT_CURRENCY_ATTRIBUTE_ID 0x0503 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0530 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0531 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0532 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0533 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0534 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0535 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0536 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0537 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0538 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0539 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x053A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x053B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0540 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0541 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0542 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0543 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0544 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0545 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0546 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0547 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0548 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0549 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0550 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0551 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0552 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0553 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_10_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0554 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_10_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0555 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_11_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0556 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_11_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0557 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_12_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0558 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_12_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0559 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_13_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x055A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_13_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x055B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x055C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PREPAYMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Energy Management +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LOAD_CONTROL_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_EVENT_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_EVENT_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CONFORMANCE_LEVEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MINIMUM_OFF_TIME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MINIMUM_ON_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_MINIMUM_CYCLE_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Calendar +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_CALENDAR_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CALENDAR_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_AUXILIARY_SWITCH_1_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_2_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_3_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_4_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_5_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_6_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_7_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_8_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_CALENDAR_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CALENDAR_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Device Management +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_TOU_TARIFF_ACTIVATION_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_BLOCK_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_BLOCK_TOU_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_SINGLE_TARIFF_RATE_ACTIVATED_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_ASYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_SYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_TARIFF_NOT_SUPPORTED_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_PRICE_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_CURRENCY_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_CURRENCY_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_PRICE_MATRIX_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_PRICE_MATRIX_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_TARIFF_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_TARIFF_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_PUBLISH_PRICE_RECEIVED_ATTRIBUTE_ID 0x01B0 // Ver.: always +#define ZCL_PUBLISH_PRICE_ACTIONED_ATTRIBUTE_ID 0x01B1 // Ver.: always +#define ZCL_PUBLISH_PRICE_CANCELLED_ATTRIBUTE_ID 0x01B2 // Ver.: always +#define ZCL_PUBLISH_PRICE_REJECTED_ATTRIBUTE_ID 0x01B3 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_RECEIVED_ATTRIBUTE_ID 0x01B4 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_ACTIONED_ATTRIBUTE_ID 0x01B5 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_CANCELLED_ATTRIBUTE_ID 0x01B6 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_REJECTED_ATTRIBUTE_ID 0x01B7 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_RECEIVED_ATTRIBUTE_ID 0x01B8 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_ACTIONED_ATTRIBUTE_ID 0x01B9 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_CANCELLED_ATTRIBUTE_ID 0x01BA // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_REJECTED_ATTRIBUTE_ID 0x01BB // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_RECEIVED_ATTRIBUTE_ID 0x01BC // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_ACTIONED_ATTRIBUTE_ID 0x01BD // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_CANCELLED_ATTRIBUTE_ID 0x01BE // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_REJECTED_ATTRIBUTE_ID 0x01BF // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C0 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C1 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_CANCELLED_ATTRIBUTE_ID 0x01C2 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_REJECTED_ATTRIBUTE_ID 0x01C3 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_RECEIVED_ATTRIBUTE_ID 0x01C4 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_ACTIONED_ATTRIBUTE_ID 0x01C5 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_CANCELLED_ATTRIBUTE_ID 0x01C6 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_REJECTED_ATTRIBUTE_ID 0x01C7 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C8 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C9 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_CANCELLED_ATTRIBUTE_ID 0x01CA // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_REJECTED_ATTRIBUTE_ID 0x01CB // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_RECEIVED_ATTRIBUTE_ID 0x01CC // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_ACTIONED_ATTRIBUTE_ID 0x01CD // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_CANCELLED_ATTRIBUTE_ID 0x01CE // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_REJECTED_ATTRIBUTE_ID 0x01CF // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_RECEIVED_ATTRIBUTE_ID 0x01D0 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_ACTIONED_ATTRIBUTE_ID 0x01D1 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_CANCELLED_ATTRIBUTE_ID 0x01D2 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_REJECTED_ATTRIBUTE_ID 0x01D3 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01D4 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01D5 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01D6 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_REJECTED_ATTRIBUTE_ID 0x01D7 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_RECEIVED_ATTRIBUTE_ID 0x01D8 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_ACTIONED_ATTRIBUTE_ID 0x01D9 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_CANCELLED_ATTRIBUTE_ID 0x01DA // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_REJECTED_ATTRIBUTE_ID 0x01DB // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01DC // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01DD // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01DE // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_REJECTED_ATTRIBUTE_ID 0x01DF // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_RECEIVED_ATTRIBUTE_ID 0x01E0 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_ACTIONED_ATTRIBUTE_ID 0x01E1 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_CANCELLED_ATTRIBUTE_ID 0x01E2 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_REJECTED_ATTRIBUTE_ID 0x01E3 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_RECEIVED_ATTRIBUTE_ID 0x01E4 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_ACTIONED_ATTRIBUTE_ID 0x01E5 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_CANCELLED_ATTRIBUTE_ID 0x01E6 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_REJECTED_ATTRIBUTE_ID 0x01E7 // Ver.: always +#define ZCL_CHECK_METER_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_LOW_BATTERY_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_TAMPER_DETECT_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_DEVICE_MANAGEMENT_SUPPLY_STATUS_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_SUPPLY_QUALITY_ATTRIBUTE_ID 0x0204 // Ver.: always +#define ZCL_LEAK_DETECT_ATTRIBUTE_ID 0x0205 // Ver.: always +#define ZCL_SERVICE_DISCONNECT_ATTRIBUTE_ID 0x0206 // Ver.: always +#define ZCL_REVERSE_FLOW_GENERAL_ATTRIBUTE_ID 0x0207 // Ver.: always +#define ZCL_METER_COVER_REMOVED_ATTRIBUTE_ID 0x0208 // Ver.: always +#define ZCL_METER_COVER_CLOSED_ATTRIBUTE_ID 0x0209 // Ver.: always +#define ZCL_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020A // Ver.: always +#define ZCL_NO_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020B // Ver.: always +#define ZCL_BATTERY_FAILURE_ATTRIBUTE_ID 0x020C // Ver.: always +#define ZCL_PROGRAM_MEMORY_ERROR_ATTRIBUTE_ID 0x020D // Ver.: always +#define ZCL_RAM_ERROR_ATTRIBUTE_ID 0x020E // Ver.: always +#define ZCL_NV_MEMORY_ERROR_ATTRIBUTE_ID 0x020F // Ver.: always +#define ZCL_LOW_VOLTAGE_L1_ATTRIBUTE_ID 0x0210 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L1_ATTRIBUTE_ID 0x0211 // Ver.: always +#define ZCL_LOW_VOLTAGE_L2_ATTRIBUTE_ID 0x0212 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L2_ATTRIBUTE_ID 0x0213 // Ver.: always +#define ZCL_LOW_VOLTAGE_L3_ATTRIBUTE_ID 0x0214 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L3_ATTRIBUTE_ID 0x0215 // Ver.: always +#define ZCL_OVER_CURRENT_L1_ATTRIBUTE_ID 0x0216 // Ver.: always +#define ZCL_OVER_CURRENT_L2_ATTRIBUTE_ID 0x0217 // Ver.: always +#define ZCL_OVER_CURRENT_L3_ATTRIBUTE_ID 0x0218 // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L1_ATTRIBUTE_ID 0x0219 // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L1_ATTRIBUTE_ID 0x021A // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L2_ATTRIBUTE_ID 0x021B // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L2_ATTRIBUTE_ID 0x021C // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L3_ATTRIBUTE_ID 0x021D // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L3_ATTRIBUTE_ID 0x021E // Ver.: always +#define ZCL_GROUND_FAULT_ATTRIBUTE_ID 0x021F // Ver.: always +#define ZCL_ELECTRIC_TAMPER_DETECT_ATTRIBUTE_ID 0x0220 // Ver.: always +#define ZCL_INCORRECT_POLARITY_ATTRIBUTE_ID 0x0221 // Ver.: always +#define ZCL_CURRENT_NO_VOLTAGE_ATTRIBUTE_ID 0x0222 // Ver.: always +#define ZCL_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0223 // Ver.: always +#define ZCL_OVER_VOLTAGE_ATTRIBUTE_ID 0x0224 // Ver.: always +#define ZCL_NORMAL_VOLTAGE_ATTRIBUTE_ID 0x0225 // Ver.: always +#define ZCL_PF_BELOW_THRESHOLD_ATTRIBUTE_ID 0x0226 // Ver.: always +#define ZCL_PF_ABOVE_THRESHOLD_ATTRIBUTE_ID 0x0227 // Ver.: always +#define ZCL_TERMINAL_COVER_REMOVED_ATTRIBUTE_ID 0x0228 // Ver.: always +#define ZCL_TERMINAL_COVER_CLOSED_ATTRIBUTE_ID 0x0229 // Ver.: always +#define ZCL_BURST_DETECT_ATTRIBUTE_ID 0x0230 // Ver.: always +#define ZCL_PRESSURE_TOO_LOW_ATTRIBUTE_ID 0x0231 // Ver.: always +#define ZCL_PRESSURE_TOO_HIGH_ATTRIBUTE_ID 0x0232 // Ver.: always +#define ZCL_FLOW_SENSOR_COMMUNICATION_ERROR_ATTRIBUTE_ID 0x0233 // Ver.: always +#define ZCL_FLOW_SENSOR_MEASUREMENT_FAULT_ATTRIBUTE_ID 0x0234 // Ver.: always +#define ZCL_FLOW_SENSOR_REVERSE_FLOW_ATTRIBUTE_ID 0x0235 // Ver.: always +#define ZCL_FLOW_SENSOR_AIR_DETECT_ATTRIBUTE_ID 0x0236 // Ver.: always +#define ZCL_PIPE_EMPTY_ATTRIBUTE_ID 0x0237 // Ver.: always +#define ZCL_INLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0250 // Ver.: always +#define ZCL_OUTLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0251 // Ver.: always +#define ZCL_REVERSE_FLOW_ATTRIBUTE_ID 0x0260 // Ver.: always +#define ZCL_TILT_TAMPER_ATTRIBUTE_ID 0x0261 // Ver.: always +#define ZCL_BATTERY_COVER_REMOVED_ATTRIBUTE_ID 0x0262 // Ver.: always +#define ZCL_BATTERY_COVER_CLOSED_ATTRIBUTE_ID 0x0263 // Ver.: always +#define ZCL_EXCESS_FLOW_ATTRIBUTE_ID 0x0264 // Ver.: always +#define ZCL_TILT_TAMPER_ENABLED_ATTRIBUTE_ID 0x0265 // Ver.: always +#define ZCL_MEASUREMENT_SYSTEM_ERROR_ATTRIBUTE_ID 0x0270 // Ver.: always +#define ZCL_WATCHDOG_ERROR_ATTRIBUTE_ID 0x0271 // Ver.: always +#define ZCL_SUPPLY_DISCONNECT_FAILURE_ATTRIBUTE_ID 0x0272 // Ver.: always +#define ZCL_SUPPLY_CONNECT_FAILURE_ATTRIBUTE_ID 0x0273 // Ver.: always +#define ZCL_MEASUREMENT_SOFTWARE_CHANGED_ATTRIBUTE_ID 0x0274 // Ver.: always +#define ZCL_DST_ENABLED_ATTRIBUTE_ID 0x0275 // Ver.: always +#define ZCL_DST_DISABLED_ATTRIBUTE_ID 0x0276 // Ver.: always +#define ZCL_CLOCK_ADJ_BACKWARD_ATTRIBUTE_ID 0x0277 // Ver.: always +#define ZCL_CLOCK_ADJ_FORWARD_ATTRIBUTE_ID 0x0278 // Ver.: always +#define ZCL_CLOCK_INVALID_ATTRIBUTE_ID 0x0279 // Ver.: always +#define ZCL_COMMUNICATION_ERROR_HAN_ATTRIBUTE_ID 0x027A // Ver.: always +#define ZCL_COMMUNICATION_OK_HAN_ATTRIBUTE_ID 0x027B // Ver.: always +#define ZCL_METER_FRAUD_ATTEMPT_ATTRIBUTE_ID 0x027C // Ver.: always +#define ZCL_POWER_LOSS_ATTRIBUTE_ID 0x027D // Ver.: always +#define ZCL_UNUSUAL_HAN_TRAFFIC_ATTRIBUTE_ID 0x027E // Ver.: always +#define ZCL_UNEXPECTED_CLOCK_CHANGE_ATTRIBUTE_ID 0x027F // Ver.: always +#define ZCL_COMMS_USING_UNAUTHENTICATED_COMPONENT_ATTRIBUTE_ID 0x0280 // Ver.: always +#define ZCL_METERING_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0281 // Ver.: always +#define ZCL_METERING_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0282 // Ver.: always +#define ZCL_UNEXPECTED_HW_RESET_ATTRIBUTE_ID 0x0283 // Ver.: always +#define ZCL_UNEXPECTED_PROGRAM_EXECUTION_ATTRIBUTE_ID 0x0284 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_EXCEEDED_ATTRIBUTE_ID 0x0285 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_OK_ATTRIBUTE_ID 0x0286 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_CHANGED_ATTRIBUTE_ID 0x0287 // Ver.: always +#define ZCL_MAXIMUM_DEMAND_EXCEEDED_ATTRIBUTE_ID 0x0288 // Ver.: always +#define ZCL_PROFILE_CLEARED_ATTRIBUTE_ID 0x0289 // Ver.: always +#define ZCL_LOAD_PROFILE_CLEARED_ATTRIBUTE_ID 0x028A // Ver.: always +#define ZCL_BATTERY_WARN_ATTRIBUTE_ID 0x028B // Ver.: always +#define ZCL_WRONG_SIGNATURE_ATTRIBUTE_ID 0x028C // Ver.: always +#define ZCL_NO_SIGNATURE_ATTRIBUTE_ID 0x028D // Ver.: always +#define ZCL_SIGNATURE_NOT_VALID_ATTRIBUTE_ID 0x028E // Ver.: always +#define ZCL_UNAUTHORISE_ACTION_FROM_HAN_ATTRIBUTE_ID 0x028F // Ver.: always +#define ZCL_FAST_POLLING_START_ATTRIBUTE_ID 0x0290 // Ver.: always +#define ZCL_FAST_POLLING_END_ATTRIBUTE_ID 0x0291 // Ver.: always +#define ZCL_METER_REPORTING_INTERVAL_CHANGED_ATTRIBUTE_ID 0x0292 // Ver.: always +#define ZCL_DISCONNECT_TO_LOAD_LIMIT_ATTRIBUTE_ID 0x0293 // Ver.: always +#define ZCL_METER_SUPPLY_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0294 // Ver.: always +#define ZCL_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0295 // Ver.: always +#define ZCL_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0296 // Ver.: always +#define ZCL_DATA_ACCESS_VIA_LOCAL_PORT_ATTRIBUTE_ID 0x0297 // Ver.: always +#define ZCL_CONFIGURE_MIRROR_SUCCESS_ATTRIBUTE_ID 0x0298 // Ver.: always +#define ZCL_CONFIGURE_MIRROR_FAILURE_ATTRIBUTE_ID 0x0299 // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_SUCCESS_ATTRIBUTE_ID 0x029A // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_FAILURE_ATTRIBUTE_ID 0x029B // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_SUCCESS_ATTRIBUTE_ID 0x029C // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_FAILURE_ATTRIBUTE_ID 0x029D // Ver.: always +#define ZCL_STAY_AWAKE_REQUEST_HAN_ATTRIBUTE_ID 0x029E // Ver.: always +#define ZCL_STAY_AWAKE_REQUEST_WAN_ATTRIBUTE_ID 0x029F // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_A_ATTRIBUTE_ID 0x02B0 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_B_ATTRIBUTE_ID 0x02B1 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_C_ATTRIBUTE_ID 0x02B2 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_D_ATTRIBUTE_ID 0x02B3 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_E_ATTRIBUTE_ID 0x02B4 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_F_ATTRIBUTE_ID 0x02B5 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_G_ATTRIBUTE_ID 0x02B6 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_H_ATTRIBUTE_ID 0x02B7 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_I_ATTRIBUTE_ID 0x02B8 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C0 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C1 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C2 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C3 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C4 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C5 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C6 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C7 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C8 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C9 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CA // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CB // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02CC // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02CD // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CE // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CF // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D0 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D1 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02D2 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D3 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D4 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D5 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02D6 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D7 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D8 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D9 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DA // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DB // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02DC // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02DD // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DE // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DF // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02E0 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02E1 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02E2 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x02E3 // Ver.: always +#define ZCL_SUPPLY_ON_ATTRIBUTE_ID 0x02E4 // Ver.: always +#define ZCL_SUPPLY_ARMED_ATTRIBUTE_ID 0x02E5 // Ver.: always +#define ZCL_SUPPLY_OFF_ATTRIBUTE_ID 0x02E6 // Ver.: always +#define ZCL_DISCONNECTED_DUE_TO_TAMPER_DETECTED_ATTRIBUTE_ID 0x02E7 // Ver.: always +#define ZCL_MANUAL_DISCONNECT_ATTRIBUTE_ID 0x02E8 // Ver.: always +#define ZCL_MANUAL_CONNECT_ATTRIBUTE_ID 0x02E9 // Ver.: always +#define ZCL_REMOTE_DISCONNECTION_ATTRIBUTE_ID 0x02EA // Ver.: always +#define ZCL_REMOTE_CONNECT_ATTRIBUTE_ID 0x02EB // Ver.: always +#define ZCL_LOCAL_DISCONNECTION_ATTRIBUTE_ID 0x02EC // Ver.: always +#define ZCL_LOCAL_CONNECT_ATTRIBUTE_ID 0x02ED // Ver.: always +#define ZCL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02EE // Ver.: always +#define ZCL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02EF // Ver.: always +#define ZCL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F0 // Ver.: always +#define ZCL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F1 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02F2 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02F3 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F4 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F5 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_RECEIVED_ATTRIBUTE_ID 0x02F6 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_ACTIONED_ATTRIBUTE_ID 0x02F7 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_CANCELLED_ATTRIBUTE_ID 0x02F8 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_REJECTED_ATTRIBUTE_ID 0x02F9 // Ver.: always +#define ZCL_MESSAGE_CONFIRMATION_SENT_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C0 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C1 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C2 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C3 // Ver.: always +#define ZCL_CANCEL_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C4 // Ver.: always +#define ZCL_CANCEL_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C5 // Ver.: always +#define ZCL_CANCEL_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C6 // Ver.: always +#define ZCL_CANCEL_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C7 // Ver.: always +#define ZCL_LOW_CREDIT_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_NO_CREDIT_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_ENABLED_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_PREPAY_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_PHYSICAL_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0420 // Ver.: always +#define ZCL_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0421 // Ver.: always +#define ZCL_DISCOUNT_APPLIED_ATTRIBUTE_ID 0x0422 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_ATTRIBUTE_ID 0x0423 // Ver.: always +#define ZCL_CREDIT_ADJUST_FAIL_ATTRIBUTE_ID 0x0424 // Ver.: always +#define ZCL_DEBT_ADJUSTMENT_ATTRIBUTE_ID 0x0425 // Ver.: always +#define ZCL_DEBT_ADJUST_FAIL_ATTRIBUTE_ID 0x0426 // Ver.: always +#define ZCL_MODE_CHANGE_ATTRIBUTE_ID 0x0427 // Ver.: always +#define ZCL_TOPUP_CODE_ERROR_ATTRIBUTE_ID 0x0428 // Ver.: always +#define ZCL_TOPUP_ALREADY_USED_ATTRIBUTE_ID 0x0429 // Ver.: always +#define ZCL_TOPUP_CODE_INVALID_ATTRIBUTE_ID 0x042A // Ver.: always +#define ZCL_TOPUP_ACCEPTED_VIA_REMOTE_ATTRIBUTE_ID 0x042B // Ver.: always +#define ZCL_TOPUP_ACCEPTED_VIA_MANUAL_ENTRY_ATTRIBUTE_ID 0x042C // Ver.: always +#define ZCL_FRIENDLY_CREDIT_IN_USE_ATTRIBUTE_ID 0x042D // Ver.: always +#define ZCL_FRIENDLY_CREDIT_END_WARNING_ATTRIBUTE_ID 0x042E // Ver.: always +#define ZCL_FRIENDLY_CREDIT_PERIOD_END_ATTRIBUTE_ID 0x042F // Ver.: always +#define ZCL_PREPAY_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0430 // Ver.: always +#define ZCL_PREPAY_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0431 // Ver.: always +#define ZCL_PREPAY_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0432 // Ver.: always +#define ZCL_TOPUP_VALUE_TOO_LARGE_ATTRIBUTE_ID 0x0433 // Ver.: always +#define ZCL_MODE_CREDIT_2_PREPAY_ATTRIBUTE_ID 0x0441 // Ver.: always +#define ZCL_MODE_PREPAY_2_CREDIT_ATTRIBUTE_ID 0x0442 // Ver.: always +#define ZCL_MODE_DEFAULT_ATTRIBUTE_ID 0x0443 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_RECEIVED_ATTRIBUTE_ID 0x04C0 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_ACTIONED_ATTRIBUTE_ID 0x04C1 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_CANCELLED_ATTRIBUTE_ID 0x04C2 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_REJECTED_ATTRIBUTE_ID 0x04C3 // Ver.: always +#define ZCL_CHANGE_DEBT_RECEIVED_ATTRIBUTE_ID 0x04C4 // Ver.: always +#define ZCL_CHANGE_DEBT_ACTIONED_ATTRIBUTE_ID 0x04C5 // Ver.: always +#define ZCL_CHANGE_DEBT_CANCELLED_ATTRIBUTE_ID 0x04C6 // Ver.: always +#define ZCL_CHANGE_DEBT_REJECTED_ATTRIBUTE_ID 0x04C7 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_RECEIVED_ATTRIBUTE_ID 0x04C8 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_ACTIONED_ATTRIBUTE_ID 0x04C9 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_CANCELLED_ATTRIBUTE_ID 0x04CA // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_REJECTED_ATTRIBUTE_ID 0x04CB // Ver.: always +#define ZCL_CONSUMER_TOPUP_RECEIVED_ATTRIBUTE_ID 0x04CC // Ver.: always +#define ZCL_CONSUMER_TOPUP_ACTIONED_ATTRIBUTE_ID 0x04CD // Ver.: always +#define ZCL_CONSUMER_TOPUP_CANCELLED_ATTRIBUTE_ID 0x04CE // Ver.: always +#define ZCL_CONSUMER_TOPUP_REJECTED_ATTRIBUTE_ID 0x04CF // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_RECEIVED_ATTRIBUTE_ID 0x04D0 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_ACTIONED_ATTRIBUTE_ID 0x04D1 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_CANCELLED_ATTRIBUTE_ID 0x04D2 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_REJECTED_ATTRIBUTE_ID 0x04D3 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_RECEIVED_ATTRIBUTE_ID 0x04D4 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_ACTIONED_ATTRIBUTE_ID 0x04D5 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_CANCELLED_ATTRIBUTE_ID 0x04D6 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_REJECTED_ATTRIBUTE_ID 0x04D7 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_RECEIVED_ATTRIBUTE_ID 0x04D8 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_ACTIONED_ATTRIBUTE_ID 0x04D9 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_CANCELLED_ATTRIBUTE_ID 0x04DA // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_REJECTED_ATTRIBUTE_ID 0x04DB // Ver.: always +#define ZCL_GET_TOPUP_LOG_RECEIVED_ATTRIBUTE_ID 0x04DC // Ver.: always +#define ZCL_GET_TOPUP_LOG_ACTIONED_ATTRIBUTE_ID 0x04DD // Ver.: always +#define ZCL_GET_TOPUP_LOG_CANCELLED_ATTRIBUTE_ID 0x04DE // Ver.: always +#define ZCL_GET_TOPUP_LOG_REJECTED_ATTRIBUTE_ID 0x04DF // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_RECEIVED_ATTRIBUTE_ID 0x04E0 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_ACTIONED_ATTRIBUTE_ID 0x04E1 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_CANCELLED_ATTRIBUTE_ID 0x04E2 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_REJECTED_ATTRIBUTE_ID 0x04E3 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_RECEIVED_ATTRIBUTE_ID 0x04E4 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_ACTIONED_ATTRIBUTE_ID 0x04E5 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_CANCELLED_ATTRIBUTE_ID 0x04E6 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_REJECTED_ATTRIBUTE_ID 0x04E7 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_RECEIVED_ATTRIBUTE_ID 0x04E8 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_ACTIONED_ATTRIBUTE_ID 0x04E9 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_CANCELLED_ATTRIBUTE_ID 0x04EA // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_REJECTED_ATTRIBUTE_ID 0x04EB // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_RECEIVED_ATTRIBUTE_ID 0x04EC // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_ACTIONED_ATTRIBUTE_ID 0x04ED // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_CANCELLED_ATTRIBUTE_ID 0x04EE // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_REJECTED_ATTRIBUTE_ID 0x04EF // Ver.: always +#define ZCL_CALENDAR_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_CALENDAR_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0501 // Ver.: always +#define ZCL_CALENDAR_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0502 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_RECEIVED_ATTRIBUTE_ID 0x05C0 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_ACTIONED_ATTRIBUTE_ID 0x05C1 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_CANCELLED_ATTRIBUTE_ID 0x05C2 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_REJECTED_ATTRIBUTE_ID 0x05C3 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C4 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C5 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05C6 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_REJECTED_ATTRIBUTE_ID 0x05C7 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C8 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C9 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05CA // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_REJECTED_ATTRIBUTE_ID 0x05CB // Ver.: always +#define ZCL_PUBLISH_SEASONS_RECEIVED_ATTRIBUTE_ID 0x05CC // Ver.: always +#define ZCL_PUBLISH_SEASONS_ACTIONED_ATTRIBUTE_ID 0x05CD // Ver.: always +#define ZCL_PUBLISH_SEASONS_CANCELLED_ATTRIBUTE_ID 0x05CE // Ver.: always +#define ZCL_PUBLISH_SEASONS_REJECTED_ATTRIBUTE_ID 0x05CF // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_RECEIVED_ATTRIBUTE_ID 0x05D0 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_ACTIONED_ATTRIBUTE_ID 0x05D1 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_CANCELLED_ATTRIBUTE_ID 0x05D2 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_REJECTED_ATTRIBUTE_ID 0x05D3 // Ver.: always +#define ZCL_PASSWORD_1_CHANGE_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_PASSWORD_2_CHANGE_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_PASSWORD_3_CHANGE_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_PASSWORD_4_CHANGE_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_EVENT_LOG_CLEARED_ATTRIBUTE_ID 0x0604 // Ver.: always +#define ZCL_ZIGBEE_APS_TIMEOUT_ATTRIBUTE_ID 0x0610 // Ver.: always +#define ZCL_ZIGBEE_IEEE_TRANSMISSION_FAILURE_OVER_THRESHOLD_ATTRIBUTE_ID 0x0611 // Ver.: always +#define ZCL_ZIGBEE_IEEE_FRAME_CHECK_SEQUENCE_THRESHOLD_ATTRIBUTE_ID 0x0612 // Ver.: always +#define ZCL_ERROR_CERTIFICATE_ATTRIBUTE_ID 0x0613 // Ver.: always +#define ZCL_ERROR_SIGNATURE_ATTRIBUTE_ID 0x0614 // Ver.: always +#define ZCL_ERROR_PROGRAM_STORAGE_ATTRIBUTE_ID 0x0615 // Ver.: always +#define ZCL_PUBLISH_COT_RECEIVED_ATTRIBUTE_ID 0x06C0 // Ver.: always +#define ZCL_PUBLISH_COT_ACTIONED_ATTRIBUTE_ID 0x06C1 // Ver.: always +#define ZCL_PUBLISH_COT_CANCELLED_ATTRIBUTE_ID 0x06C2 // Ver.: always +#define ZCL_PUBLISH_COT_REJECTED_ATTRIBUTE_ID 0x06C3 // Ver.: always +#define ZCL_PUBLISH_COS_RECEIVED_ATTRIBUTE_ID 0x06C4 // Ver.: always +#define ZCL_PUBLISH_COS_ACTIONED_ATTRIBUTE_ID 0x06C5 // Ver.: always +#define ZCL_PUBLISH_COS_CANCELLED_ATTRIBUTE_ID 0x06C6 // Ver.: always +#define ZCL_PUBLISH_COS_REJECTED_ATTRIBUTE_ID 0x06C7 // Ver.: always +#define ZCL_CHANGE_PASSWORD_RECEIVED_ATTRIBUTE_ID 0x06C8 // Ver.: always +#define ZCL_CHANGE_PASSWORD_ACTIONED_ATTRIBUTE_ID 0x06C9 // Ver.: always +#define ZCL_CHANGE_PASSWORD_CANCELLED_ATTRIBUTE_ID 0x06CA // Ver.: always +#define ZCL_CHANGE_PASSWORD_REJECTED_ATTRIBUTE_ID 0x06CB // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_RECEIVED_ATTRIBUTE_ID 0x06CC // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_ACTIONED_ATTRIBUTE_ID 0x06CD // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_CANCELLED_ATTRIBUTE_ID 0x06CE // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_REJECTED_ATTRIBUTE_ID 0x06CF // Ver.: always +#define ZCL_UPDATE_SITE_ID_RECEIVED_ATTRIBUTE_ID 0x06D0 // Ver.: always +#define ZCL_UPDATE_SITE_ID_ACTIONED_ATTRIBUTE_ID 0x06D1 // Ver.: always +#define ZCL_UPDATE_SITE_ID_CANCELLED_ATTRIBUTE_ID 0x06D2 // Ver.: always +#define ZCL_UPDATE_SITE_ID_REJECTED_ATTRIBUTE_ID 0x06D3 // Ver.: always +#define ZCL_UPDATE_CIN_RECEIVED_ATTRIBUTE_ID 0x06D4 // Ver.: always +#define ZCL_UPDATE_CIN_ACTIONED_ATTRIBUTE_ID 0x06D5 // Ver.: always +#define ZCL_UPDATE_CIN_CANCELLED_ATTRIBUTE_ID 0x06D6 // Ver.: always +#define ZCL_UPDATE_CIN_REJECTED_ATTRIBUTE_ID 0x06D7 // Ver.: always +#define ZCL_TUNNELING_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0700 // Ver.: always +#define ZCL_UNSUPPORTED_PROTOCOL_ATTRIBUTE_ID 0x0701 // Ver.: always +#define ZCL_INCORRECT_PROTOCOL_ATTRIBUTE_ID 0x0702 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C0 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C1 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C2 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C3 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C4 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C5 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C6 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C7 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C8 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C9 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CA // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CB // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CC // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CD // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CE // Ver.: always +#define ZCL_READY_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CF // Ver.: always +#define ZCL_READY_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D0 // Ver.: always +#define ZCL_READY_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D1 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07D2 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D3 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D4 // Ver.: always +#define ZCL_FIRMWARE_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0800 // Ver.: always +#define ZCL_FIRMWARE_ACTIVATED_ATTRIBUTE_ID 0x0801 // Ver.: always +#define ZCL_FIRMWARE_ACTIVATION_FAILURE_ATTRIBUTE_ID 0x0802 // Ver.: always +#define ZCL_PATCH_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0803 // Ver.: always +#define ZCL_PATCH_ACTIVATED_ATTRIBUTE_ID 0x0804 // Ver.: always +#define ZCL_PATCH_FAILURE_ATTRIBUTE_ID 0x0805 // Ver.: always +#define ZCL_IMAGE_NOTIFY_COMMAND_RECEIVED_ATTRIBUTE_ID 0x08C0 // Ver.: always +#define ZCL_IMAGE_NOTIFY_COMMAND_REJECTED_ATTRIBUTE_ID 0x08C1 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C2 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C3 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C4 // Ver.: always +#define ZCL_IMAGE_BLOCK_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C5 // Ver.: always +#define ZCL_IMAGE_PAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C6 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C7 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C8 // Ver.: always +#define ZCL_UPGRADE_END_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C9 // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CA // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CB // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08CC // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CD // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CE // Ver.: always +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_PROVIDER_NAME_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0113 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0120 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_NAME_ATTRIBUTE_ID 0x0121 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0122 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0130 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0131 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0132 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0133 // Ver.: always +#define ZCL_CHANGE_OF_TENANCY_UPDATE_DATE_TIME_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_PROPOSED_TENANCY_CHANGE_CONTROL_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_WAN_STATUS_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_LOW_MEDIUM_THRESHOLD_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_MEDIUM_HIGH_THRESHOLD_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Events +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_EVENTS_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_EVENTS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_EVENTS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_EVENTS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: MDU Pairing +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_MDU_PAIRING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MDU_PAIRING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MDU_PAIRING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MDU_PAIRING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sub-GHz +// Cluster specification level: se-1.2b-15-0131-02 + +// Client attributes +#define ZCL_SUB_GHZ_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SUB_GHZ_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SUB_GHZ_CLUSTER_CHANNEL_CHANGE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_28_CHANNEL_MASK_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_29_CHANNEL_MASK_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_30_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_31_CHANNEL_MASK_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SUB_GHZ_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Key Establishment +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client attributes +#define ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_KEY_ESTABLISHMENT_SUITE_SERVER_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Information +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_INFORMATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_INFORMATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_NODE_DESCRIPTION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DELIVERY_ENABLE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PUSH_INFORMATION_TIMER_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ENABLE_SECURE_CONFIGURATION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_CONTENTS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_CONTENT_ROOT_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_INFORMATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_INFORMATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Data Sharing +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_DATA_SHARING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DATA_SHARING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_DEVICE_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DEVICE_DESCRIPTION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DATA_SHARING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DATA_SHARING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Gaming +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_GAMING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GAMING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PLAYER_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NB_OF_GAMES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LIST_OF_GAMES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ANNOUNCEMENT_INTERVAL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_GAME_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_NAME_OF_GAME_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_GAME_MASTER_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_GAMING_STATUS_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_CURRENT_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_LIST_OF_CURRENT_PLAYERS_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_MAX_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MIN_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_CURRENT_GAME_LEVEL_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_SCORE_OF_THIS_PLAYER_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_TIMER1_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_TIMER2_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_TIMER3_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_COUNTER1_ATTRIBUTE_ID 0x001D // Ver.: always +#define ZCL_COUNTER2_ATTRIBUTE_ID 0x001E // Ver.: always +#define ZCL_DOWNLOADABLE_ATTRIBUTE_ID 0x001F // Ver.: always +#define ZCL_GAMING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_GAMING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Data Rate Control +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_DATA_RATE_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DATA_RATE_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_AVERAGE_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAX_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BANDWIDTH_REQUIREMENT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DATA_RATE_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DATA_RATE_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Voice over ZigBee +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_CODEC_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLING_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CODEC_RATE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ESTABLISHMENT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CODEC_TYPE_SUB1_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_CODEC_TYPE_SUB2_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_CODEC_TYPE_SUB3_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_COMPRESSION_TYPE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_COMPRESSION_RATE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_OPTION_FLAGS_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_THRESHOLD_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Chatting +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_CHATTING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHATTING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_U_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NICKNAME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_C_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_NAME_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_ENABLE_ADD_CHAT_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_CHATTING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHATTING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Payment +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_PAYMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PAYMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PAYMENT_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_USER_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PAYMENT_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PAYMENT_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_TOTEM_ID_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CURRENCY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_PRICE_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_GOOD_ID_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_SERIAL_NUMBER_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_PAYMENT_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_TRANS_ID_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_TRANS_STATUS_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_PAYMENT_STATUS_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_PAYMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PAYMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Billing +// Cluster specification level: ta-1.0-07-5307-07 + +// Client attributes +#define ZCL_BILLING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BILLING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SESSION_INTERVAL_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_TIMESTAMP_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_DURATION_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_BILLING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BILLING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Appliance Identification +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_BASIC_IDENTIFICATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_APPLIANCE_COMPANY_NAME_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COMPANY_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_BRAND_NAME_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_BRAND_ID_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_APPLIANCE_MODEL_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_APPLIANCE_PART_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_APPLIANCE_PRODUCT_REVISION_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_APPLIANCE_SOFTWARE_REVISION_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_PRODUCT_TYPE_NAME_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_PRODUCT_TYPE_ID_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_CECED_SPECIFICATION_VERSION_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Meter Identification +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_METER_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_METER_IDENTIFICATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_METER_COMPANY_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_METER_TYPE_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DATA_QUALITY_ID_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_CUSTOMER_NAME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_METER_MODEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_METER_PART_NUMBER_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_METER_PRODUCT_REVISION_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_METER_SOFTWARE_REVISION_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_UTILITY_NAME_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_POD_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_AVAILABLE_POWER_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_POWER_THRESHOLD_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_METER_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_METER_IDENTIFICATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Appliance Events and Alert +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Appliance Statistics +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_LOG_MAX_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOG_QUEUE_MAX_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Electrical Measurement +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_MEASUREMENT_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DC_VOLTAGE_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_DC_VOLTAGE_MIN_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_DC_VOLTAGE_MAX_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_DC_CURRENT_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_DC_CURRENT_MIN_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_DC_CURRENT_MAX_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_DC_POWER_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_DC_POWER_MIN_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_DC_POWER_MAX_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_DC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_DC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0204 // Ver.: always +#define ZCL_DC_POWER_DIVISOR_ATTRIBUTE_ID 0x0205 // Ver.: always +#define ZCL_AC_FREQUENCY_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_AC_FREQUENCY_MIN_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_AC_FREQUENCY_MAX_ATTRIBUTE_ID 0x0302 // Ver.: always +#define ZCL_NEUTRAL_CURRENT_ATTRIBUTE_ID 0x0303 // Ver.: always +#define ZCL_TOTAL_ACTIVE_POWER_ATTRIBUTE_ID 0x0304 // Ver.: always +#define ZCL_TOTAL_REACTIVE_POWER_ATTRIBUTE_ID 0x0305 // Ver.: always +#define ZCL_TOTAL_APPARENT_POWER_ATTRIBUTE_ID 0x0306 // Ver.: always +#define ZCL_MEASURED_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0307 // Ver.: always +#define ZCL_MEASURED_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0308 // Ver.: always +#define ZCL_MEASURED_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0309 // Ver.: always +#define ZCL_MEASURED_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030A // Ver.: always +#define ZCL_MEASURED_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030B // Ver.: always +#define ZCL_MEASURED_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030C // Ver.: always +#define ZCL_MEASURED_PHASE_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030D // Ver.: always +#define ZCL_MEASURED_PHASE_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030E // Ver.: always +#define ZCL_MEASURED_PHASE_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030F // Ver.: always +#define ZCL_MEASURED_PHASE_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0310 // Ver.: always +#define ZCL_MEASURED_PHASE_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0311 // Ver.: always +#define ZCL_MEASURED_PHASE_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0312 // Ver.: always +#define ZCL_AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_POWER_DIVISOR_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID 0x0501 // Ver.: always +#define ZCL_INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID 0x0502 // Ver.: always +#define ZCL_INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID 0x0503 // Ver.: always +#define ZCL_INSTANTANEOUS_POWER_ATTRIBUTE_ID 0x0504 // Ver.: always +#define ZCL_RMS_VOLTAGE_ATTRIBUTE_ID 0x0505 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_ATTRIBUTE_ID 0x0506 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_ATTRIBUTE_ID 0x0507 // Ver.: always +#define ZCL_RMS_CURRENT_ATTRIBUTE_ID 0x0508 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_ATTRIBUTE_ID 0x0509 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_ATTRIBUTE_ID 0x050A // Ver.: always +#define ZCL_ACTIVE_POWER_ATTRIBUTE_ID 0x050B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_ATTRIBUTE_ID 0x050C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_ATTRIBUTE_ID 0x050D // Ver.: always +#define ZCL_REACTIVE_POWER_ATTRIBUTE_ID 0x050E // Ver.: always +#define ZCL_APPARENT_POWER_ATTRIBUTE_ID 0x050F // Ver.: always +#define ZCL_AC_POWER_FACTOR_ATTRIBUTE_ID 0x0510 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0511 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID 0x0513 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0514 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0515 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID 0x0516 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID 0x0517 // Ver.: always +#define ZCL_AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_AC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_AC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0604 // Ver.: always +#define ZCL_AC_POWER_DIVISOR_ATTRIBUTE_ID 0x0605 // Ver.: always +#define ZCL_DC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0700 // Ver.: always +#define ZCL_DC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0701 // Ver.: always +#define ZCL_DC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0702 // Ver.: always +#define ZCL_AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0800 // Ver.: always +#define ZCL_AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0801 // Ver.: always +#define ZCL_AC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0802 // Ver.: always +#define ZCL_AC_POWER_OVERLOAD_ATTRIBUTE_ID 0x0803 // Ver.: always +#define ZCL_AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID 0x0804 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID 0x0805 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0806 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID 0x0807 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0808 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_ATTRIBUTE_ID 0x0809 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_ATTRIBUTE_ID 0x080A // Ver.: always +#define ZCL_LINE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0901 // Ver.: always +#define ZCL_ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0902 // Ver.: always +#define ZCL_REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0903 // Ver.: always +#define ZCL_RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID 0x0905 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID 0x0906 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID 0x0907 // Ver.: always +#define ZCL_RMS_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0908 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID 0x0909 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID 0x090A // Ver.: always +#define ZCL_ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID 0x090C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID 0x090D // Ver.: always +#define ZCL_REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090E // Ver.: always +#define ZCL_APPARENT_POWER_PHASE_B_ATTRIBUTE_ID 0x090F // Ver.: always +#define ZCL_POWER_FACTOR_PHASE_B_ATTRIBUTE_ID 0x0910 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0911 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0912 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0913 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0914 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0915 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0916 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0917 // Ver.: always +#define ZCL_LINE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A01 // Ver.: always +#define ZCL_ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A02 // Ver.: always +#define ZCL_REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A03 // Ver.: always +#define ZCL_RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID 0x0A05 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID 0x0A06 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID 0x0A07 // Ver.: always +#define ZCL_RMS_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A08 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID 0x0A09 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0A // Ver.: always +#define ZCL_ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID 0x0A0C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0D // Ver.: always +#define ZCL_REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0E // Ver.: always +#define ZCL_APPARENT_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0F // Ver.: always +#define ZCL_POWER_FACTOR_PHASE_C_ATTRIBUTE_ID 0x0A10 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A11 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A12 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A13 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A14 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A15 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A16 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A17 // Ver.: always +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Diagnostics +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_DIAGNOSTICS_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DIAGNOSTICS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_NUMBER_OF_RESETS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PERSISTENT_MEMORY_WRITES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAC_RX_BCAST_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_MAC_TX_BCAST_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_MAC_RX_UCAST_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_MAC_TX_UCAST_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_MAC_TX_UCAST_RETRY_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_MAC_TX_UCAST_FAIL_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_APS_RX_BCAST_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_APS_TX_BCAST_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_APS_RX_UCAST_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_APS_UCAST_SUCCESS_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_APS_TX_UCAST_RETRY_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_APS_TX_UCAST_FAIL_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_ROUTE_DISC_INITIATED_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_NEIGHBOR_ADDED_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_NEIGHBOR_REMOVED_ATTRIBUTE_ID 0x010E // Ver.: always +#define ZCL_NEIGHBOR_STALE_ATTRIBUTE_ID 0x010F // Ver.: always +#define ZCL_JOIN_INDICATION_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_CHILD_MOVED_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_NWK_FC_FAILURE_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_APS_FC_FAILURE_ATTRIBUTE_ID 0x0113 // Ver.: always +#define ZCL_APS_UNAUTHORIZED_KEY_ATTRIBUTE_ID 0x0114 // Ver.: always +#define ZCL_NWK_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0115 // Ver.: always +#define ZCL_APS_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0116 // Ver.: always +#define ZCL_PACKET_BUFFER_ALLOC_FAILURES_ATTRIBUTE_ID 0x0117 // Ver.: always +#define ZCL_RELAYED_UNICAST_ATTRIBUTE_ID 0x0118 // Ver.: always +#define ZCL_PHY_TO_MAC_QUEUE_LIMIT_REACHED_ATTRIBUTE_ID 0x0119 // Ver.: always +#define ZCL_PACKET_VALIDATE_DROP_COUNT_ATTRIBUTE_ID 0x011A // Ver.: always +#define ZCL_AVERAGE_MAC_RETRY_PER_APS_MSG_SENT_ATTRIBUTE_ID 0x011B // Ver.: always +#define ZCL_LAST_MESSAGE_LQI_ATTRIBUTE_ID 0x011C // Ver.: always +#define ZCL_LAST_MESSAGE_RSSI_ATTRIBUTE_ID 0x011D // Ver.: always +#define ZCL_DIAGNOSTICS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DIAGNOSTICS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: ZLL Commissioning +// Cluster specification level: zll-1.0-11-0037-10 + +// Client attributes +#define ZCL_ZLL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ZLL_COMMISSIONING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ZLL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ZLL_COMMISSIONING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sample Mfg Specific Cluster +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ATTRIBUTE_ONE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ATTRIBUTE_TWO_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Sample Mfg Specific Cluster 2 +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_ATTRIBUTE_THREE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ATTRIBUTE_FOUR_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: Configuration Cluster +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_OTA_CONFIGURATION_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OTA_CONFIGURATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_TOKENS_LOCKED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OTA_CONFIGURATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_OTA_CONFIGURATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: MFGLIB Cluster +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_MFGLIB_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MFGLIB_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_PACKETS_RECEIVED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAVED_RSSI_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAVED_LQI_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MFGLIB_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MFGLIB_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +// Attribute types for cluster: SL Works With All Hubs +// Cluster specification level: UNKNOWN + +// Client attributes +#define ZCL_SL_WWAH_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SL_WWAH_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + +// Server attributes +#define ZCL_SL_DISABLE_OTA_DOWNGRADES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SL_MGMT_LEAVE_WITHOUT_REJOIN_ENABLED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SL_NWK_RETRY_COUNT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_SL_MAC_RETRY_COUNT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_SL_ROUTER_CHECKIN_ENABLED_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_SL_TOUCHLINK_INTERPAN_ENABLED_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_SL_WWAH_PARENT_CLASSIFICATION_ENABLED_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_SL_WWAH_APP_EVENT_RETRY_ENABLED_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_SL_WWAH_APP_EVENT_RETRY_QUEUE_SIZE_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_SL_WWAH_REJOIN_ENABLED_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_SL_MAC_POLL_FAILURE_WAIT_TIME_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_SL_CONFIGURATION_MODE_ENABLED_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_SL_CURRENT_DEBUG_REPORT_ID_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_SL_TC_SECURITY_ON_NTWK_KEY_ROTATION_ENABLED_ATTRIBUTE_ID 0x000F // Ver.: always +#define ZCL_SL_WWAH_BAD_PARENT_RECOVERY_ENABLED_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SL_PENDING_NETWORK_UPDATE_CHANNEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SL_PENDING_NETWORK_UPDATE_PANID_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_SL_OTA_MAX_OFFLINE_DURATION_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_SL_WWAH_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SL_WWAH_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 + + +#endif // SILABS_EMBER_AF_ATTRIBUTE_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-size.h b/examples/wifi-echo/server/esp32/main/gen/attribute-size.h new file mode 100644 index 00000000000000..e84131dfeef166 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-size.h @@ -0,0 +1,68 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_ATTRIBUTE_SIZE +#define SILABS_ATTRIBUTE_SIZE + + +// Used ZCL attribute type sizes + ZCL_BITMAP16_ATTRIBUTE_TYPE, 2, + ZCL_BITMAP24_ATTRIBUTE_TYPE, 3, + ZCL_BITMAP32_ATTRIBUTE_TYPE, 4, + ZCL_BITMAP48_ATTRIBUTE_TYPE, 6, + ZCL_BITMAP64_ATTRIBUTE_TYPE, 8, + ZCL_BITMAP8_ATTRIBUTE_TYPE, 1, + ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, + ZCL_DATA8_ATTRIBUTE_TYPE, 1, + ZCL_ENUM16_ATTRIBUTE_TYPE, 2, + ZCL_ENUM8_ATTRIBUTE_TYPE, 1, + ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE, 4, + ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE, 8, + ZCL_INT16S_ATTRIBUTE_TYPE, 2, + ZCL_INT16U_ATTRIBUTE_TYPE, 2, + ZCL_INT24S_ATTRIBUTE_TYPE, 3, + ZCL_INT24U_ATTRIBUTE_TYPE, 3, + ZCL_INT32S_ATTRIBUTE_TYPE, 4, + ZCL_INT32U_ATTRIBUTE_TYPE, 4, + ZCL_INT48U_ATTRIBUTE_TYPE, 6, + ZCL_INT56U_ATTRIBUTE_TYPE, 7, + ZCL_INT8S_ATTRIBUTE_TYPE, 1, + ZCL_INT8U_ATTRIBUTE_TYPE, 1, + ZCL_SECURITY_KEY_ATTRIBUTE_TYPE, 16, + ZCL_UTC_TIME_ATTRIBUTE_TYPE, 4, +#endif // SILABS_ATTRIBUTE_SIZE diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-type.h b/examples/wifi-echo/server/esp32/main/gen/attribute-type.h new file mode 100644 index 00000000000000..d817c5d2889b19 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-type.h @@ -0,0 +1,103 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_ATTRIBUTE_TYPES +#define SILABS_EMBER_AF_ATTRIBUTE_TYPES + + +// ZCL attribute types +enum { + ZCL_NO_DATA_ATTRIBUTE_TYPE = 0x00, // No data + ZCL_DATA8_ATTRIBUTE_TYPE = 0x08, // 8-bit data + ZCL_DATA16_ATTRIBUTE_TYPE = 0x09, // 16-bit data + ZCL_DATA24_ATTRIBUTE_TYPE = 0x0A, // 24-bit data + ZCL_DATA32_ATTRIBUTE_TYPE = 0x0B, // 32-bit data + ZCL_DATA40_ATTRIBUTE_TYPE = 0x0C, // 40-bit data + ZCL_DATA48_ATTRIBUTE_TYPE = 0x0D, // 48-bit data + ZCL_DATA56_ATTRIBUTE_TYPE = 0x0E, // 56-bit data + ZCL_DATA64_ATTRIBUTE_TYPE = 0x0F, // 64-bit data + ZCL_BOOLEAN_ATTRIBUTE_TYPE = 0x10, // Boolean + ZCL_BITMAP8_ATTRIBUTE_TYPE = 0x18, // 8-bit bitmap + ZCL_BITMAP16_ATTRIBUTE_TYPE = 0x19, // 16-bit bitmap + ZCL_BITMAP24_ATTRIBUTE_TYPE = 0x1A, // 24-bit bitmap + ZCL_BITMAP32_ATTRIBUTE_TYPE = 0x1B, // 32-bit bitmap + ZCL_BITMAP40_ATTRIBUTE_TYPE = 0x1C, // 40-bit bitmap + ZCL_BITMAP48_ATTRIBUTE_TYPE = 0x1D, // 48-bit bitmap + ZCL_BITMAP56_ATTRIBUTE_TYPE = 0x1E, // 56-bit bitmap + ZCL_BITMAP64_ATTRIBUTE_TYPE = 0x1F, // 64-bit bitmap + ZCL_INT8U_ATTRIBUTE_TYPE = 0x20, // Unsigned 8-bit integer + ZCL_INT16U_ATTRIBUTE_TYPE = 0x21, // Unsigned 16-bit integer + ZCL_INT24U_ATTRIBUTE_TYPE = 0x22, // Unsigned 24-bit integer + ZCL_INT32U_ATTRIBUTE_TYPE = 0x23, // Unsigned 32-bit integer + ZCL_INT40U_ATTRIBUTE_TYPE = 0x24, // Unsigned 40-bit integer + ZCL_INT48U_ATTRIBUTE_TYPE = 0x25, // Unsigned 48-bit integer + ZCL_INT56U_ATTRIBUTE_TYPE = 0x26, // Unsigned 56-bit integer + ZCL_INT64U_ATTRIBUTE_TYPE = 0x27, // Unsigned 64-bit integer + ZCL_INT8S_ATTRIBUTE_TYPE = 0x28, // Signed 8-bit integer + ZCL_INT16S_ATTRIBUTE_TYPE = 0x29, // Signed 16-bit integer + ZCL_INT24S_ATTRIBUTE_TYPE = 0x2A, // Signed 24-bit integer + ZCL_INT32S_ATTRIBUTE_TYPE = 0x2B, // Signed 32-bit integer + ZCL_INT40S_ATTRIBUTE_TYPE = 0x2C, // Signed 40-bit integer + ZCL_INT48S_ATTRIBUTE_TYPE = 0x2D, // Signed 48-bit integer + ZCL_INT56S_ATTRIBUTE_TYPE = 0x2E, // Signed 56-bit integer + ZCL_INT64S_ATTRIBUTE_TYPE = 0x2F, // Signed 64-bit integer + ZCL_ENUM8_ATTRIBUTE_TYPE = 0x30, // 8-bit enumeration + ZCL_ENUM16_ATTRIBUTE_TYPE = 0x31, // 16-bit enumeration + ZCL_FLOAT_SEMI_ATTRIBUTE_TYPE = 0x38, // Semi-precision + ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE = 0x39, // Single precision + ZCL_FLOAT_DOUBLE_ATTRIBUTE_TYPE = 0x3A, // Double precision + ZCL_OCTET_STRING_ATTRIBUTE_TYPE = 0x41, // Octet string + ZCL_CHAR_STRING_ATTRIBUTE_TYPE = 0x42, // Character string + ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE = 0x43, // Long octet string + ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE = 0x44, // Long character string + ZCL_ARRAY_ATTRIBUTE_TYPE = 0x48, // Array + ZCL_STRUCT_ATTRIBUTE_TYPE = 0x4C, // Structure + ZCL_SET_ATTRIBUTE_TYPE = 0x50, // Set + ZCL_BAG_ATTRIBUTE_TYPE = 0x51, // Bag + ZCL_TIME_OF_DAY_ATTRIBUTE_TYPE = 0xE0, // Time of day + ZCL_DATE_ATTRIBUTE_TYPE = 0xE1, // Date + ZCL_UTC_TIME_ATTRIBUTE_TYPE = 0xE2, // UTC Time + ZCL_CLUSTER_ID_ATTRIBUTE_TYPE = 0xE8, // Cluster ID + ZCL_ATTRIBUTE_ID_ATTRIBUTE_TYPE = 0xE9, // Attribute ID + ZCL_BACNET_OID_ATTRIBUTE_TYPE = 0xEA, // BACnet OID + ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE = 0xF0, // IEEE address + ZCL_SECURITY_KEY_ATTRIBUTE_TYPE = 0xF1, // 128-bit security key + ZCL_UNKNOWN_ATTRIBUTE_TYPE = 0xFF // Unknown + +}; +#endif // SILABS_EMBER_AF_ATTRIBUTE_TYPES diff --git a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c new file mode 100644 index 00000000000000..28fd312db58b01 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c @@ -0,0 +1,137 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// This is a set of generated functions that parse the +// the incomming message, and call appropriate command handler. + + + +#include PLATFORM_HEADER +#ifdef EZSP_HOST +// Includes needed for ember related functions for the EZSP host +#include "stack/include/error.h" +#include "stack/include/ember-types.h" +#include "app/util/ezsp/ezsp-protocol.h" +#include "app/util/ezsp/ezsp.h" +#include "app/util/ezsp/ezsp-utils.h" +#include "app/util/ezsp/serial-interface.h" +#else +// Includes needed for ember related functions for the EM250 +#include "stack/include/ember.h" +#endif // EZSP_HOST + +#include "app/framework/util/util.h" +#include "af-structs.h" +#include "call-command-handler.h" +#include "command-id.h" +#include "callback.h" + +static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific) +{ + if (wasHandled) { + return EMBER_ZCL_STATUS_SUCCESS; + } else if (mfgSpecific) { + return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND; + } else if (clusterExists) { + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; + } else { + return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER; + } +} + +// Main command parsing controller. +EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand *cmd) +{ + EmberAfStatus result = status(false, false, cmd->mfgSpecific); + if (cmd->direction == (uint8_t)ZCL_DIRECTION_SERVER_TO_CLIENT + && emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->clusterId, + cmd->mfgCode)) { + switch (cmd->apsFrame->clusterId) { + default: + // Unrecognized cluster ID, error status will apply. + break; + } + } else if (cmd->direction == (uint8_t)ZCL_DIRECTION_CLIENT_TO_SERVER + && emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->clusterId, + cmd->mfgCode)) { + switch (cmd->apsFrame->clusterId) { + case ZCL_ON_OFF_CLUSTER_ID: + result = emberAfOnOffClusterServerCommandParse(cmd); + break; + default: + // Unrecognized cluster ID, error status will apply. + break; + } + } + return result; +} + +// Cluster: On/off, server +EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand *cmd) +{ + bool wasHandled = false; + if (!cmd->mfgSpecific) { + switch (cmd->commandId) { + case ZCL_OFF_COMMAND_ID: + { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterOffCallback(); + break; + } + case ZCL_ON_COMMAND_ID: + { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterOnCallback(); + break; + } + case ZCL_TOGGLE_COMMAND_ID: + { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterToggleCallback(); + break; + } + default: + { + // Unrecognized command ID, error status will apply. + break; + } + } + } + return status(wasHandled, true, cmd->mfgSpecific); +} diff --git a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h new file mode 100644 index 00000000000000..6c290b42e36d62 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h @@ -0,0 +1,49 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_COMMAND_PARSE_HEADER +#define SILABS_EMBER_AF_COMMAND_PARSE_HEADER + + +// This is a set of generated prototype for functions that parse the +// the incomming message, and call appropriate command handler. + +// Cluster: On/off, server +EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand *cmd); + +#endif // SILABS_EMBER_AF_COMMAND_PARSE_HEADER diff --git a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c new file mode 100644 index 00000000000000..d76cd04d79c441 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -0,0 +1,2689 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// This c file provides stubs for all callbacks. These stubs +// will be used in the case where user defined implementations +// of the callbacks have not been provided. +#include "app/framework/include/af.h" +#include "hal/hal.h" +#include EMBER_AF_API_NETWORK_STEERING + + + +/** @brief Add To Current App Tasks + * + * This function is only useful to sleepy end devices. This function will note + * the passed item as part of a set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Until the + * outstanding task is completed, the device may poll more frequently and sleep + * less often. + * + * @param tasks Ver.: always + */ +void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks) +{ +} + +/** @brief Allow Network Write Attribute + * + * This function is called by the application framework before it writes an + * attribute in response to a write attribute request from an external device. + * The value passed into this callback is the value to which the attribute is to + * be set by the framework. + Example: In mirroring simple metering data + * on an Energy Services Interface (ESI) (formerly called Energy Service Portal + * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only + * attributes on its mirror. The-meter-mirror sample application, located in + * app/framework/sample-apps, uses this callback to allow the mirrored device to + * write simple metering attributes on the mirror regardless of the fact that + * most simple metering attributes are defined as read-only by the ZigBee + * specification. + Note: The ZCL specification does not (as of this + * writing) specify any permission-level security for writing writeable + * attributes. As far as the ZCL specification is concerned, if an attribute is + * writeable, any device that has a link key for the device should be able to + * write that attribute. Furthermore if an attribute is read only, it should not + * be written over the air. Thus, if you implement permissions for writing + * attributes as a feature, you MAY be operating outside the specification. This + * is unlikely to be a problem for writing read-only attributes, but it may be a + * problem for attributes that are writeable according to the specification but + * restricted by the application implementing this callback. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param value Ver.: always + * @param type Ver.: always + */ +EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* value, + uint8_t type) +{ + return EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL; // Default +} + +/** @brief Attribute Read Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute read. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeReadAccessCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint16_t manufacturerCode, + uint16_t attributeId) +{ + return true; +} + +/** @brief Attribute Write Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute write. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint16_t manufacturerCode, + uint16_t attributeId) +{ + return true; +} + +/** @brief Groups Cluster Clear Group Table + * + * This function is called by the framework when the application should clear + * the group table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint) +{ +} + +/** @brief Clear Report Table + * + * This function is called by the framework when the application should clear + * the report table. + * + */ +EmberStatus emberAfClearReportTableCallback(void) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Scenes Cluster ClearSceneTable + * + * This function is called by the framework when the application should clear + * the scene table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint) +{ +} + +/** @brief Key Establishment Cluster Client Command Received + * + * This function is called by the application framework when a server-to-client + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand *cmd) +{ + return false; +} + +/** @brief Cluster Init + * + * This function is called when a specific cluster is initialized. It gives the + * application an opportunity to take care of cluster initialization procedures. + * It is called exactly once for each endpoint where cluster is present. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + */ +void emberAfClusterInitCallback(uint8_t endpoint, + EmberAfClusterId clusterId) +{ +} + +/** @brief Cluster Security Custom + * + * This callback is fired when determining if APS encryption is required for a + * cluster outside of the specification's required clusters. In other words, + * for the Smart Energy profile this would be a cluster beyond the list that + * normally requires APS encryption. + * + * @param profileId The profile ID Ver.: always + * @param clusterId The cluster ID Ver.: always + * @param incoming Whether this is an incoming or outgoing message. Ver.: + * always + * @param commandId The ZCL command ID being sent/received. Ver.: always + */ +bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, + EmberAfClusterId clusterId, + bool incoming, + uint8_t commandId) +{ + // By default, assume APS encryption is not required. + return false; +} + +/** @brief Configure Reporting Command + * + * This function is called by the application framework when a Configure + * Reporting command is received from an external device. The Configure + * Reporting command contains a series of attribute reporting configuration + * records. The application should return true if the message was processed or + * false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd) +{ + return false; +} + +/** @brief Configure Reporting Response + * + * This function is called by the application framework when a Configure + * Reporting Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute status records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen) +{ + return false; +} + +/** @brief Default Response + * + * This function is called by the application framework when a Default Response + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param commandId The command identifier to which this is a response. Ver.: + * always + * @param status Specifies either SUCCESS or the nature of the error that was + * detected in the received command. Ver.: always + */ +bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status) +{ + return false; +} + +/** @brief Discover Attributes Response + * + * This function is called by the application framework when a Discover + * Attributes Response or Discover Attributes Extended Response command is + * received from an external device. The Discover Attributes Response command + * contains a bool indicating if discovery is complete and a list of zero or + * more attribute identifier/type records. The final argument indicates whether + * the response is in the extended format or not. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param discoveryComplete Indicates whether there are more attributes to be + * discovered. true if there are no more attributes to be discovered. Ver.: + * always + * @param buffer Buffer containing the list of attribute identifier/type + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + * @param extended Indicates whether the response is in the extended format or + * not. Ver.: always + */ +bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, + bool discoveryComplete, + uint8_t *buffer, + uint16_t bufLen, + bool extended) +{ + return false; +} + +/** @brief Discover Commands Generated Response + * + * This function is called by the framework when Discover Commands Generated + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, + uint16_t manufacturerCode, + bool discoveryComplete, + uint8_t *commandIds, + uint16_t commandIdCount) +{ + return false; +} + +/** @brief Discover Commands Received Response + * + * This function is called by the framework when Discover Commands Received + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, + uint16_t manufacturerCode, + bool discoveryComplete, + uint8_t *commandIds, + uint16_t commandIdCount) +{ + return false; +} + +/** @brief Eeprom Init + * + * Tells the system to initialize the EEPROM if it is not already initialized. + * + */ +void emberAfEepromInitCallback(void) +{ +} + +/** @brief Eeprom Note Initialized State + * + * Records the state of the EEPROM so that an intelligent driver (like the + * EEPROM plugin) can re-initialize the driver prior to any calls to it. + * + * @param state The state of the EEPROM, false=re-initalization needed, + * true=no-re-init needed Ver.: always + */ +void emberAfEepromNoteInitializedStateCallback(bool state) +{ +} + +/** @brief Eeprom Shutdown + * + * Tells the system to shutdown the EEPROM if it is not already shutdown. + * + */ +void emberAfEepromShutdownCallback(void) +{ +} + +/** @brief Groups Cluster Endpoint In Group + * + * This function is called by the framework when it needs to determine if an + * endpoint is a member of a group. The application should return true if the + * endpoint is a member of the group and false otherwise. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + */ +bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, + uint16_t groupId) +{ + return false; +} + +/** @brief External Attribute Read + * + * Like emberAfExternalAttributeWriteCallback above, this function is called + * when the framework needs to read an attribute that is not stored within the + * Application Framework's data structures. + All of the important + * information about the attribute itself is passed as a pointer to an + * EmberAfAttributeMetadata struct, which is stored within the application and + * used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h + This function assumes that the + * application is able to read the attribute, write it into the passed buffer, + * and return immediately. Any attributes that require a state machine for + * reading and writing are not really candidates for externalization at the + * present time. The Application Framework does not currently include a state + * machine for reading or writing attributes that must take place across a + * series of application ticks. Attributes that cannot be read in a timely + * manner should be stored within the Application Framework and updated + * occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * read the attribute and write it into the passed buffer, it should return a + * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally + * managed attribute value is smaller than what the buffer can hold. In the case + * of a buffer overflow throw an appropriate error such as + * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the + * application was not able to read the attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + * @param maxReadLength Ver.: always + */ +EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *attributeMetadata, + uint16_t manufacturerCode, + uint8_t *buffer, + uint16_t maxReadLength) +{ + return EMBER_ZCL_STATUS_FAILURE; +} + +/** @brief External Attribute Write + * + * This function is called whenever the Application Framework needs to write an + * attribute which is not stored within the data structures of the Application + * Framework itself. One of the new features in Version 2 is the ability to + * store attributes outside the Framework. This is particularly useful for + * attributes that do not need to be stored because they can be read off the + * hardware when they are needed, or are stored in some central location used by + * many modules within the system. In this case, you can indicate that the + * attribute is stored externally. When the framework needs to write an external + * attribute, it makes a call to this callback. + This callback is very + * useful for host micros which need to store attributes in persistent memory. + * Because each host micro (used with an Ember NCP) has its own type of + * persistent memory storage, the Application Framework does not include the + * ability to mark attributes as stored in flash the way that it does for Ember + * SoCs like the EM35x. On a host micro, any attributes that need to be stored + * in persistent memory should be marked as external and accessed through the + * external read and write callbacks. Any host code associated with the + * persistent storage should be implemented within this callback. + All of + * the important information about the attribute itself is passed as a pointer + * to an EmberAfAttributeMetadata struct, which is stored within the application + * and used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h. + This function assumes that the + * application is able to write the attribute and return immediately. Any + * attributes that require a state machine for reading and writing are not + * candidates for externalization at the present time. The Application Framework + * does not currently include a state machine for reading or writing attributes + * that must take place across a series of application ticks. Attributes that + * cannot be written immediately should be stored within the Application + * Framework and updated occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any + * other return value indicates the application was not able to write the + * attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + */ +EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *attributeMetadata, + uint16_t manufacturerCode, + uint8_t *buffer) +{ + return EMBER_ZCL_STATUS_FAILURE; +} + +/** @brief Find Unused Pan Id And Form + * + * This function is called by the framework to search for an unused PAN id and + * form a new network. The application should return EMBER_SUCCESS if the + * operation was initiated successfully. + * + */ +EmberStatus emberAfFindUnusedPanIdAndFormCallback(void) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Get Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * return the set of tasks the application has outstanding. These tasks affect + * how the application behaves with regard to sleeping and polling. + * + */ +EmberAfApplicationTask emberAfGetCurrentAppTasksCallback(void) +{ + return 0; +} + +/** @brief Get Current Poll Control + * + * This function will retrieve the current poll control that the system is using + * for the current network. This is determined by examining all the scheduled + * events and obtaining the most restrictive poll control context across all + * events. The most restrictive poll control is EMBER_AF_SHORT_POLL followed by + * EMBER_AF_LONG_POLL. + * + */ +EmberAfEventPollControl emberAfGetCurrentPollControlCallback(void) +{ + return EMBER_AF_LONG_POLL; +} + +/** @brief Get Current Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * current poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalMsCallback(void) +{ + return 0; +} + +/** @brief Get Current Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * current poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalQsCallback(void) +{ + return 0; +} + +/** @brief Get Current Sleep Control + * + * This function will retrieve the current sleep control that the system is + * using. This is determined by examining all the scheduled events and + * obtaining the most restrictive sleep control context across all events. The + * most restrictive sleep control is EMBER_AF_STAY_AWAKE followed by + * EMBER_AF_OK_TO_SLEEP. + * + */ +EmberAfEventSleepControl emberAfGetCurrentSleepControlCallback(void) +{ + return EMBER_AF_OK_TO_SLEEP; +} + +/** @brief Get Current Time + * + * This callback is called when device attempts to get current time from the + * hardware. If this device has means to retrieve exact time, then this method + * should implement it. If the callback can't provide the exact time it should + * return 0 to indicate failure. Default action is to return 0, which indicates + * that device does not have access to real time. + * + */ +uint32_t emberAfGetCurrentTimeCallback(void) +{ + return 0; +} + +/** @brief Get Default Poll Control + * + * This function will retrieve the default poll control for the current network + * as previously set by emberAfSetDefaultPollControlCallback(). The default + * poll control will limit whether the network can long poll. + * + */ +EmberAfEventPollControl emberAfGetDefaultPollControlCallback(void) +{ + return EMBER_AF_LONG_POLL; +} + +/** @brief Get Default Sleep Control + * + * This function will retrieve the default sleep control the system is using as + * previously set by emberAfSetDefaultSleepControlCallback(). The default sleep + * control will limit whether the device can sleep. + * + */ +EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void) +{ + return EMBER_AF_OK_TO_SLEEP; +} + +/** @brief Get Endpoint By Index + * + * Get the endpoint number based on the passed index. By default the framework + * handles this by managing endpoints based on the precompiled configuration + * defined in AppBuilder. This callback can override this behavior at runtime + * and provide additional endpoints or different data than the compiled values. + * If the index is overridden than the callback shall return true and set the + * endpointReturn parameter accordingly. A value of 0xFF means the endpoint + * doesn't exist at that index. + Otherwise false must be returned by the + * callback and the default framework behavior will be executed. This is only + * applicable to the SOC devices. + * + * @param index The index of the endpoint. Ver.: always + * @param endpointReturn The value of endpoint. Ver.: always + */ +bool emberAfGetEndpointByIndexCallback(uint8_t index, + uint8_t* endpointReturn) +{ + return false; +} + +/** @brief Get Endpoint Description + * + * This callback is called by the framework whenever it receives a ZDO request + * to enumerate the details about an endpoint. By default the framework + * provides the information based on the precompiled endpoint information as + * defined in AppBuilder. This callback can override that behavior at runtime + * and return different information. If the endpoint information is being + * overridden then the callback must return true. Otherwise it should return + * false, which allows the framework to perform its default behavior. This is + * only applicable to SOC devices. + * + * @param endpoint The endpoint number that is being queried. Ver.: always + * @param result This is a pointer to a data structure where the endpoint + * information is written if the callback is providing the information. Ver.: + * always + */ +bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, + EmberEndpointDescription* result) +{ + return false; +} + +/** @brief Get Endpoint Info + * + * This function is a callback to an application implemented endpoint that + * operates outside the normal application framework. When the framework wishes + * to perform operations with that endpoint it uses this callback to retrieve + * the endpoint's information. If the endpoint exists and the application can + * provide data then true shall be returned. Otherwise the callback must return + * false. + * + * @param endpoint The endpoint to retrieve data for. Ver.: always + * @param returnNetworkIndex The index corresponding to the ZigBee network the + * endpoint belongs to. If not using a multi-network device, 0 must be + * returned. Otherwise on a multi-network device the stack will switch to this + * network before sending the message. Ver.: always + * @param returnEndpointInfo A pointer to a data struct that will be written + * with information about the endpoint. Ver.: always + */ +bool emberAfGetEndpointInfoCallback(uint8_t endpoint, + uint8_t* returnNetworkIndex, + EmberAfEndpointInfoStruct* returnEndpointInfo) +{ + return false; +} + +/** @brief Get Form And Join Extended Pan Id + * + * This callback is called by the framework to get the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param resultLocation Ver.: always + */ +void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t *resultLocation) +{ +} + +/** @brief Get Long Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * long poll interval (in milliseconds) for the current network. This interval + * is the maximum amount of time a child will wait between polls of its parent + * when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalMsCallback(void) +{ + return 0; +} + +/** @brief Get Long Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * long poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalQsCallback(void) +{ + return 0; +} + +/** @brief Get Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in milliseconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalMsCallback(void) +{ + return 0; +} + +/** @brief Get Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in quarter seconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalQsCallback(void) +{ + return 0; +} + +/** @brief Get Source Route Overhead + * + * This function is called by the framework to determine the overhead required + * in the network frame for source routing to a particular destination. + * + * @param destination The node id of the destination Ver.: always + */ +uint8_t emberAfGetSourceRouteOverheadCallback(EmberNodeId destination) +{ + return 0; +} + +/** @brief Get Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout bitmask for the current network. The bitmask + * determines which tasks will timeout automatically and which tasks require + * manual removal from the task list. + * + */ +EmberAfApplicationTask emberAfGetWakeTimeoutBitmaskCallback(void) +{ + return 0; +} + +/** @brief Get Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in milliseconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutMsCallback(void) +{ + return 0; +} + +/** @brief Get Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in quarter seconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutQsCallback(void) +{ + return 0; +} + +/** @brief Hal Button Isr + * + * This callback is called by the framework whenever a button is pressed on the + * device. This callback is called within ISR context. + * + * @param button The button which has changed state, either BUTTON0 or BUTTON1 + * as defined in the appropriate BOARD_HEADER. Ver.: always + * @param state The new state of the button referenced by the button parameter, + * either ::BUTTON_PRESSED if the button has been pressed or ::BUTTON_RELEASED + * if the button has been released. Ver.: always + */ +void emberAfHalButtonIsrCallback(uint8_t button, + uint8_t state) +{ +} + +/** @brief Incoming Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack receives a packet from one of the + * protocol layers specified in ::EmberZigbeePacketType. + + The packetType + * argument is one of the values of the ::EmberZigbeePacketType enum. If the + * stack receives an 802.15.4 MAC beacon, it will call this function with the + * packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + The + * implementation of this callback may alter the data contained in packetData, + * modify options and flags in the auxillary data, or consume the packet itself, + * either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, + uint8_t* packetData, + uint8_t* size_p, + void* data) +{ + return EMBER_ACCEPT_PACKET; +} + +/** @brief Initiate Inter Pan Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device on a different PAN. The application should return + * EMBER_SUCCESS if key establishment was initiated successfully. The + * application should call ::emberAfInterPanKeyEstablishmentCallback as events + * occur. + * + * @param panId The PAN id of the remote device. Ver.: always + * @param eui64 The EUI64 of the remote device. Ver.: always + */ +EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, + const EmberEUI64 eui64) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Initiate Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device. The application should return EMBER_SUCCESS if key + * establishment was initiated successfully. The application should call + * ::emberAfKeyEstablishmentCallback as events occur. + * + * @param nodeId The node id of the remote device. Ver.: always + * @param endpoint The endpoint on the remote device. Ver.: always + */ +EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, + uint8_t endpoint) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Initiate Partner Link Key Exchange + * + * This function is called by the framework to initiate a partner link key + * exchange with a remote device. The application should return EMBER_SUCCESS + * if the partner link key exchange was initiated successfully. When the + * partner link key exchange completes, the application should call the given + * callback. + * + * @param target The node id of the remote device. Ver.: always + * @param endpoint The key establishment endpoint of the remote device. Ver.: + * always + * @param callback The callback that should be called when the partner link key + * exchange completse. Ver.: always + */ +EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, + uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback *callback) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Inter Pan Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param panId Ver.: always + * @param eui64 Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, + bool amInitiator, + EmberPanId panId, + const EmberEUI64 eui64, + uint8_t delayInSeconds) +{ + return true; +} + +/** @brief Interpan Send Message + * + * This function will send a raw MAC message with interpan frame format using + * the passed parameters. + * + * @param header Interpan header info Ver.: always + * @param messageLength The length of the message received or to send Ver.: + * always + * @param message The message data received or to send. Ver.: always + */ +EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, + uint16_t messageLength, + uint8_t* message) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param partnerShortId Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, + bool amInitiator, + EmberNodeId partnerShortId, + uint8_t delayInSeconds) +{ + return true; +} + +/** @brief On/off Cluster Level Control Effect + * + * This is called by the framework when the on/off cluster initiates a command + * that must effect a level control change. The implementation assumes that the + * client will handle any effect on the On/Off Cluster. + * + * @param endpoint Ver.: always + * @param newValue Ver.: always + */ +void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, + bool newValue) +{ +} + +/** @brief Main Init + * + * This function is called from the application's main function. It gives the + * application a chance to do any initialization required at system startup. Any + * code that you would normally put into the top of the application's main() + * routine should be put into this function. This is called before the clusters, + * plugins, and the network are initialized so some functionality is not yet + * available. + Note: No callback in the Application Framework is + * associated with resource cleanup. If you are implementing your application on + * a Unix host where resource cleanup is a consideration, we expect that you + * will use the standard Posix system calls, including the use of atexit() and + * handlers for signals such as SIGTERM, SIGINT, SIGCHLD, SIGPIPE and so on. If + * you use the signal() function to register your signal handler, please mind + * the returned value which may be an Application Framework function. If the + * return value is non-null, please make sure that you call the returned + * function from your handler to avoid negating the resource cleanup of the + * Application Framework itself. + * + */ +void emberAfMainInitCallback(void) +{ +} + +/** @brief Main Start + * + * This function is called at the start of main after the HAL has been + * initialized. The standard main function arguments of argc and argv are + * passed in. However not all platforms have support for main() function + * arguments. Those that do not are passed NULL for argv, therefore argv should + * be checked for NULL before using it. If the callback determines that the + * program must exit, it should return true. The value returned by main() will + * be the value written to the returnCode pointer. Otherwise the callback + * should return false to let normal execution continue. + * + * @param returnCode Ver.: always + * @param argc Ver.: always + * @param argv Ver.: always + */ +bool emberAfMainStartCallback(int* returnCode, + int argc, + char** argv) +{ + // NOTE: argc and argv may not be supported on all platforms, so argv MUST be + // checked for NULL before referencing it. On those platforms without argc + // and argv "0" and "NULL" are passed respectively. + + return false; // exit? +} + +/** @brief Main Tick + * + * Whenever main application tick is called, this callback will be called at the + * end of the main tick execution. + * + */ +void emberAfMainTickCallback(void) +{ +} + +/** @brief Scenes Cluster Make Invalid + * + * This function is called to invalidate the valid attribute in the Scenes + * cluster. + * + * @param endpoint Ver.: always + */ +EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint) +{ + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; +} + +/** @brief Mark Buffers + * + * This function is called when the garbage collector runs. Any buffers held by + * the application must be marked. + * + */ +void emberAfMarkBuffersCallback(void) +{ + //emMarkBuffer(&bufferUsed); +} + +/** @brief Message Sent + * + * This function is called by the application framework from the message sent + * handler, when it is informed by the stack regarding the message sent status. + * All of the values passed to the emberMessageSentHandler are passed on to this + * callback. This provides an opportunity for the application to verify that its + * message has been sent successfully and take the appropriate action. This + * callback should return a bool value of true or false. A value of true + * indicates that the message sent notification has been handled and should not + * be handled by the application framework. + * + * @param type Ver.: always + * @param indexOrDestination Ver.: always + * @param apsFrame Ver.: always + * @param msgLen Ver.: always + * @param message Ver.: always + * @param status Ver.: always + */ +bool emberAfMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame* apsFrame, + uint16_t msgLen, + uint8_t* message, + EmberStatus status) +{ + return false; +} + +/** @brief Ncp Init + * + * This function is called when the network coprocessor is being initialized, + * either at startup or upon reset. It provides applications on opportunity to + * perform additional configuration of the NCP. The function is always called + * twice when the NCP is initialized. In the first invocation, memoryAllocation + * will be true and the application should only issue EZSP commands that affect + * memory allocation on the NCP. For example, tables on the NCP can be resized + * in the first call. In the second invocation, memoryAllocation will be false + * and the application should only issue EZSP commands that do not affect memory + * allocation. For example, tables on the NCP can be populated in the second + * call. This callback is not called on SoCs. + * + * @param memoryAllocation Ver.: always + */ +void emberAfNcpInitCallback(bool memoryAllocation) +{ +} + +/** @brief Ncp Is Awake Isr + * + * This function is called IN ISR CONTEXT. It notes that the NCP is awake after + * sleeping. Care should be taken to do minimal processing in this ISR handler + * function. + * + */ +void emberAfNcpIsAwakeIsrCallback(void) +{ +} + +/** @brief Network Key Update Complete + * + * This is called by the framework when a network key update operation started + * by the trust center is complete. + * + * @param status Ver.: always + */ +void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status) +{ +} + +/** @brief Ota Bootload + * + * The platform specific routine to bootload the device from a ZigBee + * over-the-air upgrade file. + * + * @param id A pointer to the structure that contains the information about what + * OTA image to bootload. Ver.: always + * @param ncpUpgradeTagId The tag ID of the upgrade data that will be used to + * bootload the device. Ver.: always + */ +uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, + uint16_t ncpUpgradeTagId) +{ + // Please implement me + emberAfCorePrintln("Not supported."); + return 1; +} + +/** @brief Ota Client Bootload + * + * This callback is fired when the OTA Client recevies a command to bootload the + * newly downloaded OTA image. This callback will perform the platform specific + * to bootload their device. + * + * @param id This is the identifier relating to the image that has been + * downloaded and is ready for bootload. Ver.: always + */ +void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id) +{ + // Any final preperation prior to the bootload should be done here. + // It is assumed that the device will reset in most all cases. + // Please implement me. +} + +/** @brief Ota Client Custom Verify + * + * This callback is executed by the OTA client after the signature verification + * has successfully completed. It allows the device to do its own custom + * verification of the image (such as verifying that the EBL is intact). + * + * @param newVerification This indicates if a new verification should be + * started. Ver.: always + * @param id This is ID of the image to be verified. Ver.: always + */ +EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, + const EmberAfOtaImageId* id) +{ + // Manufacturing specific checks can be made to the image in this function to + // determine if it is valid. This function is called AFTER cryptographic + // checks have passed. If the cryptographic checks failed, this function will + // never be called. + + // The function shall return one of the following based on its own + // verification process. + // 1) EMBER_AF_IMAGE_GOOD - the image has passed all checks + // 2) EMBER_AF_IMAGE_BAD - the image is not valid + // 3) EMBER_AF_IMAGE_VERIFY_IN_PROGRESS - the image is valid so far, but more + // checks are needed. This callback shall be re-executed later to + // continue verification. This allows other code in the framework to run. + return EMBER_AF_IMAGE_GOOD; +} + +/** @brief Ota Client Download Complete + * + * This callback indicates that the OTA client has completed the download of a + * file. If the file has been completely downloaded and cryptographic checks + * have been turned on, then those will be performed prior to this callback and + * that outcome included in the 'success' result. On failure, this callback is + * merely informative, and the return type is ignored. On succesful download, + * this callback allows the client to perform any additional verification of the + * downloaded image and return that result to the OTA server. + * + * @param success This indicates the success or failure of the download and + * cryptographic verification process (if applicable). Ver.: always + * @param id This is the image identifier information that corresponds to the + * download result. Ver.: always + */ +bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, + const EmberAfOtaImageId* id) +{ + // At this point the image has been completely downloaded and cryptographic + // checks (if applicable) have been performed. + + if (!success) { + emberAfOtaBootloadClusterPrintln("Download failed."); + return true; // return value is ignored + } + + // This is for any additional validation that needs to be performed + // on the image by the application. + + // The results of checks here will be returned back to the OTA server + // in the Upgrade End request. + return true; +} + +/** @brief Ota Client Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster client. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand *message) +{ + return false; +} + +/** @brief Ota Client Start + * + * This callback should be called when the profile specific registration has + * completed successfully. It will start the client's state machine that will + * find the OTA server, query it for the next image, download the image, wait + * for the bootload message, and kick off the bootload. + * + */ +void emberAfOtaClientStartCallback(void) +{ +} + +/** @brief Ota Client Version Info + * + * This function is called by the OTA client when a new query will occur to the + * server asking what the next version of firmware is. The client can inform + * the cluster software as to what information to use in the query (and + * subsequent download). + * + * @param currentImageInfo This is the information to use in the next query by + * the client cluster code. It contains the manufacturer ID, image type ID, and + * the firmware version to be specified in the query message sent to the server. + * Ver.: always + * @param hardwareVersion This is a pointer to the hardware version to use in + * the query. If no hardware version should be used, then + * EMBER_AF_INVALID_HARDWARE_VERSION should be used. Ver.: always + */ +void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId* currentImageInfo, + uint16_t* hardwareVersion) +{ + // Customer will fill in the image info with their manufacturer ID, + // image type ID, and current software version number. + // The deviceSpecificFileEui64 can be ignored. + + // It may be necessary to dynamically determine this by talking to + // another device, as is the case with a host talking to an NCP device. + + // However, this routine will be called repeatedly so it may be wise + // to cache the data! + +/* This is commented out since the #defines below are not defined. + + if (currentImageInfo != NULL) { + MEMSET(currentImageInfo, 0, sizeof(EmberAfOtaImageId)); + currentImageInfo->manufacturerId = EMBER_AF_MANUFACTURER_CODE; + currentImageInfo->imageTypeId = EMBER_AF_IMAGE_TYPE_ID; + currentImageInfo->firmwareVersion = EMBER_AF_CUSTOM_FIRMWARE_VERSION; + } + + if (hardwareVersion != NULL) { + *hardwareVersion = EMBER_AF_INVALID_HARDWARE_VERSION; + } + + assert(false); +*/ +} + +/** @brief Ota Page Request Server Policy + * + * This callback is called by the OTA server page request code when it wants to + * determine if it is allowed for an OTA client to make a page request. It is + * only called if page request support has been enabled on the server. It + * should return EMBER_ZCL_STATUS_SUCCESS if it allows the page request, and + * EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND if it does not want to allow it. + * + */ +uint8_t emberAfOtaPageRequestServerPolicyCallback(void) +{ + return EMBER_ZCL_STATUS_SUCCESS; +} + +/** @brief Ota Server Block Size + * + * This function provides a way for the server to adjust the block size of its + * response to an Image block request by a client. + * + * @param clientNodeId The node Id of OTA client making an image block request. + * Ver.: always + */ +uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId) +{ + // This function provides a way for the server to potentially + // adjust the block size based on the client who is requesting. + // In other words if we are using source routing we will limit + // data returned by enough to put a source route into the message. + + // Image Block Response Message Format + // Status Code: 1-byte + // Manuf Code: 2-bytes + // Image Type: 2-bytes + // File Ver: 4-bytes + // File Offset: 4-bytes + // Data Size: 1-byte + // Data: variable + const uint8_t IMAGE_BLOCK_RESPONSE_OVERHEAD = (EMBER_AF_ZCL_OVERHEAD + 14); + + EmberApsFrame apsFrame; + uint8_t maxSize; + apsFrame.options = EMBER_APS_OPTION_NONE; + + if (emberAfIsCurrentSecurityProfileSmartEnergy()) { + apsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } + + maxSize = emberAfMaximumApsPayloadLength(EMBER_OUTGOING_DIRECT, + clientNodeId, + &apsFrame); + maxSize -= IMAGE_BLOCK_RESPONSE_OVERHEAD; + return maxSize; +} + +/** @brief Ota Server Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster server. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message) +{ + return false; +} + +/** @brief Ota Server Query + * + * This callback is fired when the OTA server receives a query request by the + * client. The callback lets the server application indicate to the client what + * the 'next' version of software is for the device, or if there is not one + * available. + * + * @param currentImageId This is the current software image that the client + * hase. Ver.: always + * @param hardwareVersion If this value is non-NULL, it indicates the hardware + * version of the client device. If NULL, the client did not specify a hardware + * version. Ver.: always + * @param nextUpgradeImageId This is a pointer to a data structure containing + * the 'next' software version for the client to download. Ver.: always + */ +uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, + uint16_t* hardwareVersion, + EmberAfOtaImageId* nextUpgradeImageId) +{ + // If a new software image is available, this function should return EMBER_ZCL_STATUS_SUCCESS + // and populate the 'nextUpgradeImageId' structure with the appropriate values. + // If no new software image is available (i.e. the client should not download a firmware image) + // then the server should return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE. + return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE; +} + +/** @brief Ota Server Send Image Notify + * + * This callback is an indication to the OTA server that it should send out + * notification about an OTA file that is available for download. + * + * @param dest The destination of the image notify message. May be a broadcast + * address. Ver.: always + * @param endpoint The destination endpoint of the image notify message. May be + * a broadcast endpoint. Ver.: always + * @param payloadType The type of data the image notify message will contain. 0 + * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. + * 3 = Manufacturer ID, image type ID, and firmware version. Ver.: always + * @param queryJitter The percentage of nodes that should respond to this + * message, from 1-100. On receipt of this message, each recipient will + * randomly choose a percentage and only query the server if their percentage is + * below this value. Ver.: always + * @param id The image information that will be put in the message. The data + * within this struct that will be appended to the message is determined by the + * previous 'payloadType' argument. Ver.: always + */ +bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, + uint8_t endpoint, + uint8_t payloadType, + uint8_t queryJitter, + const EmberAfOtaImageId* id) +{ + return false; +} + +/** @brief Ota Server Upgrade End Request + * + * This function is called when the OTA server receives a request an upgrade end + * request. If the request indicated a successful download by the client, the + * server must tell the client when and if to upgrade to the downloaded image. + * + * @param source The node ID of the device that sent the upgrade end request. + * Ver.: always + * @param status This is the ZCL status sent by the client indicating the result + * of its attempt to download the new upgrade image. If the status is not + * EMBER_ZCL_STATUS_SUCCESS then this callback is merely informative and no + * response mesasge will be generated by the server. Ver.: always + * @param returnValue If the server returns true indicating that the client + * should apply the upgrade, this time value indicates when in the future the + * client should apply the upgrade. Ver.: always + * @param imageId This variable indicates the software version that the client + * successfully downloaded and is asking to upgrade to. Ver.: always + */ +bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, + uint8_t status, + uint32_t* returnValue, + const EmberAfOtaImageId* imageId) +{ + // If the status value is not EMBER_ZCL_STATUS_SUCCESS, then this callback is + // merely informative and no response message will be generated by the server. + // If the server wants the client to NOT apply the upgrade, then it should + // return false. + // If the server wants the client to apply the upgrade, it should return true + // and set the 'returnValue' parameter to when it wants the client to + // apply the upgrade. There are three possible values: + // 0 = Apply the upgrade now + // 0xFFFFFFFF = Don't apply yet, ask again later. + // (anything-else) = Apply the upgrade X minutes from now. + *returnValue = 0; + return true; +} + +/** @brief Ota Storage Check Temp Data + * + * This callback will validate temporary data in the storage device to determine + * whether it is a complete file, a partially downloaded file, or there is no + * file present. When a complete or partial file is found it will return + * EMBER_AF_OTA_STORAGE_SUCCESS or EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND, + * respectively. In that case, the currentOffset, totalImageSize, and + * newFileInfo will be populated with data. When EMBER_AF_OTA_STORAGE_ERROR is + * returned, no temporary data is present. + * + * @param currentOffset A pointer to a value that will be written with the + * offset within the total file size that has been successfully stored in the + * storage device. This will indicate how much data has been currently + * dowloaded. Ver.: always + * @param totalImageSize A pointer to a value that will be written with the + * total image size of the OTA file when a download has completed. This does + * not indicate how much data has actually been downloaded currently. Ver.: + * always + * @param newFileInfo This is the image id of the temporary file data stored in + * the storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t* currentOffset, + uint32_t* totalImageSize, + EmberAfOtaImageId* newFileInfo) +{ + // If the image data cannot be successfully verified, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Clear Temp Data + * + * This function clears any existing temp data that was downloaed. It is used + * immediately prior to downloading a raw image over the air. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageClearTempDataCallback(void) +{ + // If the image data cannot be stored, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Close + * + * This callback shuts down the ZigBee Over-the-air storage module. + * + */ +void emberAfOtaStorageCloseCallback(void) +{ + // Please implement me. + assert(false); +} + +/** @brief Ota Storage Driver Download Finish + * + * This callback defines the low-level means by which a device records the final + * offset value of the download image. + * + * @param offset The value of the final offset of the image download. Ver.: + * always + */ +void emberAfOtaStorageDriverDownloadFinishCallback(uint32_t offset) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); +} + +/** @brief Ota Storage Driver Init + * + * The initialization code for the OTA storage driver. + * + */ +bool emberAfOtaStorageDriverInitCallback(void) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; +} + +/** @brief Ota Storage Driver Invalidate Image + * + * This callback invalidates the image stored on disk so that it will not be + * bootloaded, and it will not be a valid image that is in the middle of + * downloading. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverInvalidateImageCallback(void) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Driver Prepare To Resume Download + * + * This callback allows the underlying storage driver to prepare to resume the + * OTA file download. For example, the driver may exceute a page erase to + * insure the next page is ready to be written to. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(void) +{ + assert(false); + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Driver Read + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param offset The address offset from the start of the storage device where + * data is to be read. Ver.: always + * @param length The length of the data to be read from the storage device. + * Ver.: always + * @param returnData A pointer where the data read from the device should be + * written to. Ver.: always + */ +bool emberAfOtaStorageDriverReadCallback(uint32_t offset, + uint32_t length, + uint8_t* returnData) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; +} + +/** @brief Ota Storage Driver Retrieve Last Stored Offset + * + * This callback defines the low-level means by which a device retrieves the + * last persistently recorded download offset. This may be different than last + * actual download offset. + * + */ +uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return 0; +} + +/** @brief Ota Storage Driver Write + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param dataToWrite A pointer to the data that will be written to the storage + * device. Ver.: always + * @param offset The address offset from the start of the storage device where + * data will be written. Ver.: always + * @param length The length of the data to be written to the storage device. + * Ver.: always + */ +bool emberAfOtaStorageDriverWriteCallback(const uint8_t* dataToWrite, + uint32_t offset, + uint32_t length) +{ + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; +} + +/** @brief Ota Storage Finish Download + * + * This function indicates to the storage module that the download has finished. + * + * @param offset The final offset of the downloaded file (i.e. the total size) + * Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset) +{ + return EMBER_AF_OTA_STORAGE_SUCCESS; +} + +/** @brief Ota Storage Get Count + * + * This callback returns the total number of ZigBee Over-the-air upgrade images + * stored in the storage module. + * + */ +uint8_t emberAfOtaStorageGetCountCallback(void) +{ + return 0; +} + +/** @brief Ota Storage Get Full Header + * + * This callback populates the EmberAfOtaHeader structure pointed to by the + * returnData with data about the OTA file stored in the storage module. + * + * @param id This is a pointer to the image id for the OTA file to retrieve + * information about. Ver.: always + * @param returnData This is a pointer to the location of the structure that + * will be populated with data. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId* id, + EmberAfOtaHeader* returnData) +{ + // If the requested image cannot be found, then an error shouldb e returned. + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Get Total Image Size + * + * This function returns the total size of the ZigBee Over-the-air file with the + * passed parameters. If no file is found with those parameters, 0 is returned. + * + * @param id A pointer to the image identifier for the OTA file to retrieve + * information for. Ver.: always + */ +uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId* id) +{ + // On failure this should return an image size of zero. + return 0; +} + +/** @brief Ota Storage Init + * + * This callback initializes the ZigBee Over-the-air storage module. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageInitCallback(void) +{ + return EMBER_AF_OTA_STORAGE_SUCCESS; +} + +/** @brief Ota Storage Iterator First + * + * This callback lets you walk through the list of all OTA files by jumping to + * the first file in the list maintained by the storage module. If there is no + * file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorFirstCallback(void) +{ + // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will manipulate. + + // If there are no images at all, this function should return the invalid image id. + return emberAfInvalidImageId; +} + +/** @brief Ota Storage Iterator Next + * + * This callback lets you walk through the list of all OTA files by jumping to + * the next file in the list maintained by the storage module. If there is no + * next file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void) +{ + // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will manipulate. + + // If there are no more images, this function should return the invalid image id. + return emberAfInvalidImageId; +} + +/** @brief Ota Storage Read Image Data + * + * This callback reads data from the specified OTA file and returns that data to + * the caller. + * + * @param id This is a pointer to the image id for the OTA file to retrieve data + * from. Ver.: always + * @param offset This is the offset relative to the start of the image where the + * data should be read from. Ver.: always + * @param length This is the length of data that will be read. Ver.: always + * @param returnData This is a pointer to where the data read out of the file + * will be written to Ver.: always + * @param returnedLength This is a pointer to a variable where the actual length + * of data read will be written to. A short read may occur if the end of file + * was reached. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId* id, + uint32_t offset, + uint32_t length, + uint8_t* returnData, + uint32_t* returnedLength) +{ + // If the requested image cannot be found, then an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Ota Storage Search + * + * This callback searches through the list of all images for one that matches + * the passed parameters. On success an image identifier is returned with a + * matching image. On failure emberAfInvalidImageId is returned. + * + * @param manufacturerId The ZigBee assigned identifier of the manufacturer + * contained in the OTA image being searched for. Ver.: always + * @param imageTypeId The image type identifier contained in the OTA image being + * searched for. Ver.: always + * @param hardwareVersion This is a pointer to the hardware version that will be + * used in the search. If the pointer is NULL, hardware version will not be + * considered when searching for matching images. If it points to a value, the + * search will only consider images where that value falls between the minimum + * and maxmimum hardware version specified in the OTA file. If no hardware + * version is present in an OTA file but the other parameters match, the file + * will be considered a match Ver.: always + */ +EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, + uint16_t imageTypeId, + const uint16_t* hardwareVersion) +{ + // If no image is found that matches the search criteria, this function should return the invalid image id. + return emberAfInvalidImageId; +} + +/** @brief Ota Storage Write Temp Data + * + * This function writes to the temporary data in the storage device at the + * specified offset. It is used when downloading a raw image over the air. + * + * @param offset The location within the download image file where to write the + * data. Ver.: always + * @param length The length of data to write. Ver.: always + * @param data A pointer to the temporary data that will be written to the + * storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, + uint32_t length, + const uint8_t* data) +{ + // If the image data cannot be stored, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; +} + +/** @brief Outgoing Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack prepares to send a packet from one + * of the protocol layers specified in ::EmberZigbeePacketType. + + The + * packetType argument is one of the values of the ::EmberZigbeePacketType enum. + * If the stack receives an 802.15.4 MAC beacon, it will call this function with + * the packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + + * The implementation of this callback may alter the data contained in + * packetData, modify options and flags in the auxillary data, or consume the + * packet itself, either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, + uint8_t* packetData, + uint8_t* size_p, + void* data) +{ + return EMBER_ACCEPT_PACKET; +} + +/** @brief Partner Link Key Exchange Request + * + * This function is called by the framework on SOC platforms when a remote node + * requests a partner link key exchange. The application should return + * EMBER_SUCCESS to accept the request or any other status to reject it. On + * network coprocessor platforms, this function will not be called because the + * NCP handles partner link key exchange requests based on the binding policy. + * + * @param partner The EUI of the remote node. Ver.: always + */ +EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner) +{ + return EMBER_ZDP_NOT_SUPPORTED; +} + +/** @brief Partner Link Key Exchange Response + * + * This function is called by the framework when a remote node requests a + * partner link key exchange. The application should return true to accept the + * request or false to reject it. On network coprocessor platforms, this + * function will not be called because the NCP handles partner link key exchange + * requests based on the binding policy. + * + * @param sender The EUI of the remote node. Ver.: always + * @param status The ZDO response status. Ver.: always + */ +void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, + EmberZdoStatus status) +{ +} + +/** @brief Performing Key Establishment + * + * This function is called by the framework to determine if the device is + * performing key establishment. The application should return true if key + * establishment is in progress. + * + */ +bool emberAfPerformingKeyEstablishmentCallback(void) +{ + return false; +} + +/** @brief Get Distributed Key + * + * This callback is fired when the Network Steering plugin needs to set the distributed + * key. The application set the distributed key from Zigbee Alliance thru this callback + * or the network steering will use the default test key. + * + * @param pointer to the distributed key struct + * @return true if the key is loaded successfully, otherwise false. + * level. Ver.: always + */ +bool emberAfPluginNetworkSteeringGetDistributedKeyCallback(EmberKeyData * key) +{ + return false; +} + +/** @brief Get Node Type + * + * This callback allows the application to set the node type that the network + * steering process will use in joining a network. + * + * @param state The current ::EmberAfPluginNetworkSteeringJoiningState. + * + * @return An ::EmberNodeType value that the network steering process will + * try to join a network as. + */ +EmberNodeType emberAfPluginNetworkSteeringGetNodeTypeCallback(EmberAfPluginNetworkSteeringJoiningState state) +{ + return ((emAfCurrentZigbeeProNetwork->nodeType == EMBER_COORDINATOR) + ? EMBER_ROUTER + : emAfCurrentZigbeeProNetwork->nodeType); +} + +/** @brief Get Power For Radio Channel + * + * This callback is fired when the Network Steering plugin needs to set the + * power level. The application has the ability to change the max power level + * used for this particular channel. + * + * @param channel The channel that the plugin is inquiring about the power + * level. Ver.: always + */ +int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t channel) +{ + return emberAfMaxPowerLevel(); +} + +/** @brief Post Attribute Change + * + * This function is called by the application framework after it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute was set by the framework. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +void emberAfPostAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t type, + uint8_t size, + uint8_t* value) +{ +} + +/** @brief Post Em4 Reset + * + * A callback called by application framework, and implemented by em4 plugin + * + */ +void emberAfPostEm4ResetCallback(void) +{ + return; +} + +/** @brief Pre Attribute Change + * + * This function is called by the application framework before it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute is to be set by the framework. The application should return + * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus + * to reject it. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t type, + uint8_t size, + uint8_t* value) +{ + return EMBER_ZCL_STATUS_SUCCESS; +} + +/** @brief Pre Cli Send + * + * This function is called by the framework when it is about to pass a message + * constructed over CLI to the stack primitives for sending. If the function + * returns true it is assumed that the callback has consumed and processed the + * message. The framework will not do any further processing on the message. + + * If the function returns false then it is assumed that the callback has + * not processed the message and the framework will continue to process + * accordingly. + * + * @param apsFrame The structure containing the APS frame Ver.: always + * @param source Source Node Id Ver.: always + * @param destination Destintion Node Id Ver.: always + * @param message Pointer to the message payload Ver.: always + * @param messageLength Length of the message payload Ver.: always + */ +bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, + EmberNodeId source, + EmberNodeId destination, + uint8_t* message, + uint16_t messageLength) +{ + return false; +} + +/** @brief Pre Command Received + * + * This callback is the second in the Application Framework's message processing + * chain. At this point in the processing of incoming over-the-air messages, the + * application has determined that the incoming message is a ZCL command. It + * parses enough of the message to populate an EmberAfClusterCommand struct. The + * Application Framework defines this struct value in a local scope to the + * command processing but also makes it available through a global pointer + * called emberAfCurrentCommand, in app/framework/util/util.c. When command + * processing is complete, this pointer is cleared. + * + * @param cmd Ver.: always + */ +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd) +{ + return false; +} + +/** @brief Pre Message Received + * + * This callback is the first in the Application Framework's message processing + * chain. The Application Framework calls it when a message has been received + * over the air but has not yet been parsed by the ZCL command-handling code. If + * you wish to parse some messages that are completely outside the ZCL + * specification or are not handled by the Application Framework's command + * handling code, you should intercept them for parsing in this callback. + + * This callback returns a Boolean value indicating whether or not the message + * has been handled. If the callback returns a value of true, then the + * Application Framework assumes that the message has been handled and it does + * nothing else with it. If the callback returns a value of false, then the + * application framework continues to process the message as it would with any + * incoming message. + Note: This callback receives a pointer to an + * incoming message struct. This struct allows the application framework to + * provide a unified interface between both Host devices, which receive their + * message through the ezspIncomingMessageHandler, and SoC devices, which + * receive their message through emberIncomingMessageHandler. + * + * @param incomingMessage Ver.: always + */ +bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage) +{ + return false; +} + +/** @brief Pre Message Send + * + * This function is called by the framework when it is about to pass a message + * to the stack primitives for sending. This message may or may not be ZCL, + * ZDO, or some other protocol. This is called prior to + any ZigBee + * fragmentation that may be done. If the function returns true it is assumed + * the callback has consumed and processed the message. The callback must also + * set the EmberStatus status code to be passed back to the caller. The + * framework will do no further processing on the message. + If the + * function returns false then it is assumed that the callback has not processed + * the mesasge and the framework will continue to process accordingly. + * + * @param messageStruct The structure containing the parameters of the APS + * message to be sent. Ver.: always + * @param status A pointer to the status code value that will be returned to the + * caller. Ver.: always + */ +bool emberAfPreMessageSendCallback(EmberAfMessageStruct* messageStruct, + EmberStatus* status) +{ + return false; +} + +/** @brief Pre Ncp Reset + * + * This function will be called prior to the reset of the NCP by the host. + * + */ +void emberAfPreNcpResetCallback(void) +{ +} + +/** @brief Pre ZDO Message Received + * + * This function passes the application an incoming ZDO message and gives the + * appictation the opportunity to handle it. By default, this callback returns + * false indicating that the incoming ZDO message has not been handled and + * should be handled by the Application Framework. + * + * @param emberNodeId Ver.: always + * @param apsFrame Ver.: always + * @param message Ver.: always + * @param length Ver.: always + */ +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, + EmberApsFrame* apsFrame, + uint8_t* message, + uint16_t length) +{ + return false; +} + +/** @brief Read Attributes Response + * + * This function is called by the application framework when a Read Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of read attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen) +{ + return false; +} + +/** @brief Read Reporting Configuration Command + * + * This function is called by the application framework when a Read Reporting + * Configuration command is received from an external device. The application + * should return true if the message was processed or false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand *cmd) +{ + return false; +} + +/** @brief Read Reporting Configuration Response + * + * This function is called by the application framework when a Read Reporting + * Configuration Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute reporting configuration + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen) +{ + return false; +} + +/** @brief Scenes Cluster Recall Saved Scene + * + * This function is called by the framework when the application should recall a + * saved scene. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, + uint16_t groupId, + uint8_t sceneId) +{ + return EMBER_ZCL_STATUS_FAILURE; +} + +/** @brief Registration Abort + * + * This callback is called when the device should abort the registration + * process. + * + */ +void emberAfRegistrationAbortCallback(void) +{ +} + +/** @brief Registration + * + * This callback is called when the device joins a network and the process of + * registration is complete. This callback provides a success value of true if + * the registration process was successful and a value of false if registration + * failed. + * + * @param success true if registration succeeded, false otherwise. Ver.: always + */ +void emberAfRegistrationCallback(bool success) +{ +} + +/** @brief Registration Start + * + * This callback is called when the device joins a network and the registration + * process should begin. The application should return EMBER_SUCCESS if the + * registration process started successfully. When registration is complete, + * the application should call emberAfRegistrationCallback with an indication of + * success or failure. + * + */ +EmberStatus emberAfRegistrationStartCallback(void) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Remote Delete Binding Permission + * + * This function is called by the framework to request permission to service the + * remote delete binding request. Return EMBER_SUCCESS to allow request, + * anything else to disallow request. + * + * @param index index to an Ember binding table entry Ver.: always + */ +EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index) +{ + return EMBER_SUCCESS; // default +} + +/** @brief Remote Set Binding Permission + * + * This function is called by the framework to request permission to service the + * remote set binding request. Return EMBER_SUCCESS to allow request, anything + * else to disallow request. + * + * @param entry Ember Binding Tablet Entry Ver.: always + */ +EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry *entry) +{ + return EMBER_SUCCESS; // default +} + +/** @brief Remove From Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * remove the passed item from the set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Removing the item + * from the list of outstanding tasks may allow the device to sleep longer and + * poll less frequently. If there are other outstanding tasks the system may + * still have to stay away and poll more often. + * + * @param tasks Ver.: always + */ +void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks) +{ +} + +/** @brief Scenes Cluster Remove Scenes In Group + * + * This function removes the scenes from a specified group. + * + * @param endpoint Endpoint Ver.: always + * @param groupId Group ID Ver.: always + */ +void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, + uint16_t groupId) +{ +} + +/** @brief Report Attributes + * + * This function is called by the application framework when a Report Attributes + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this command. Ver.: always + * @param buffer Buffer containing the list of attribute report records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen) +{ + return false; +} + +/** @brief Reporting Attribute Change + * + * This function is called by the framework when an attribute managed by the + * framework changes. The application should call this function when an + * externally-managed attribute changes. The application should use the change + * notification to inform its reporting decisions. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param data Ver.: always + */ +void emberAfReportingAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + EmberAfAttributeType type, + uint8_t *data) +{ +} + +/** @brief Scan Error + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application if an error occurs while scanning. See form-and-join + * documentation for more information. + * + * @param status The status of the scan. Ver.: always + */ +void emberAfScanErrorCallback(EmberStatus status) +{ +} + +/** @brief Security Init + * + * This callback is called by the framework to give the application a chance to + * modify the security settings of the node during network initialization. + * Depending on the context when this callback is called, the pointer to the + * initial security state may be NULL, which means the initial security state + * can no longer be modified as the node is already operating on the network. + * + * @param state Ver.: always + * @param extended Ver.: always + * @param trustCenter Ver.: always + */ +void emberAfSecurityInitCallback(EmberInitialSecurityState *state, + EmberExtendedSecurityBitmask *extended, + bool trustCenter) +{ +} + +/** @brief Key Establishment Cluster Server Command Received + * + * This function is called by the application framework when a client-to-server + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand *cmd) +{ + return false; +} + +/** @brief Set Default Poll Control + * + * This function will set the default poll control for the current network to + * control whether or not it can long poll. + * + * @param control Ver.: always + */ +void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control) +{ +} + +/** @brief Set Default Sleep Control + * + * This function will set the default behavior of a sleeping device to control + * whether or not it must stay awake. A device that stays awake does not sleep + * at all. Otherwise, the device can sleep between events when appropriate. + * + * @param control Ver.: always + */ +void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control) +{ +} + +/** @brief Set Form And Join Extended Pan Id + * + * This callback is called by the framework to set the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param extendedPanId Ver.: always + */ +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t *extendedPanId) +{ +} + +/** @brief Set Long Poll Interval Ms + * + * This function is only useful to end devices. This function will set the long + * poll interval (in milliseconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalMs Ver.: always + */ +void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs) +{ +} + +/** @brief Set Long Poll Interval Qs + * + * This function is only useful to end devices. This function will set the long + * poll interval (in quarter seconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalQs Ver.: always + */ +void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs) +{ +} + +/** @brief Set Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalMs Ver.: always + */ +void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs) +{ +} + +/** @brief Set Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalQs Ver.: always + */ +void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs) +{ +} + +/** @brief Set Source Route Overhead + * + * This function is called by the framework when it has information about the + * source route overhead to a particular destination. The application may use + * this information to cache the source route overhead. + * + * @param destination The node id of the destination Ver.: always + * @param overhead The overhead in bytes Ver.: always + */ +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, + uint8_t overhead) +{ +} + +/** @brief Set Time + * + * This callback should be implemented, if the device has access to real time + * clock, and has an ability to update that clock. The application framework + * expects to be passed the utcTime which is the number of seconds since the + * year 2000. Default implementation does nothing. Note: This function used to + * take time in year, month, day, hour, min, sec. We have changed this to + * utcTime in order to conserve code space. + * + * @param utcTime Ver.: always + */ +void emberAfSetTimeCallback(uint32_t utcTime) +{ +} + +/** @brief On/off Cluster Set Value + * + * This function is called when the on/off value needs to be set, either through + * normal channels or as a result of a level change. + * + * @param endpoint Ver.: always + * @param command Ver.: always + * @param initiatedByLevelChange Ver.: always + */ +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, + uint8_t command, + bool initiatedByLevelChange) +{ + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; +} + +/** @brief Set Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout bitmask for the current network. The bitmask determines + * which tasks will timeout automatically and which tasks require manual removal + * from the task list. + * + * @param tasks Ver.: always + */ +void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks) +{ +} + +/** @brief Set Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in milliseconds) for the current network. This timeout is + * the maximum amount of time a child will wait for a task in the wake bitmask + * to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutMs Ver.: always + */ +void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs) +{ +} + +/** @brief Set Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in quarter seconds) for the current network. This timeout + * is the maximum amount of time a child will wait for a task in the wake + * bitmask to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutQs Ver.: always + */ +void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs) +{ +} + +/** @brief Start Move + * + * This function is called to initiate the process for a device to move (rejoin) + * to a new parent. + * + */ +bool emberAfStartMoveCallback(void) +{ + return false; +} + +/** @brief Start Search For Joinable Network + * + * This function is called by the framework to search for joinable networks and + * join a network. The application should return EMBER_SUCCESS if the operation + * was initiated successfully. + * + */ +EmberStatus emberAfStartSearchForJoinableNetworkCallback(void) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Stop Move + * + * This function is called to cancel a previously scheduled move (rejoin) to a + * new parent. + * + */ +void emberAfStopMoveCallback(void) +{ +} + +/** @brief Scenes Cluster Store Current Scene + * + * This function is called by the framework when the application should store + * the current scene. If an entry already exists in the scene table with the + * same scene and group ids, the application should update the entry with the + * current scene. Otherwise, a new entry should be adde to the scene table, if + * possible. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, + uint16_t groupId, + uint8_t sceneId) +{ + return EMBER_ZCL_STATUS_FAILURE; +} + +/** @brief Trust Center Join + * + * This callback is called from within the application framework's + * implementation of emberTrustCenterJoinHandler or ezspTrustCenterJoinHandler. + * This callback provides the same arguments passed to the + * TrustCenterJoinHandler. For more information about the TrustCenterJoinHandler + * please see documentation included in stack/include/trust-center.h. + * + * @param newNodeId Ver.: always + * @param newNodeEui64 Ver.: always + * @param parentOfNewNode Ver.: always + * @param status Ver.: always + * @param decision Ver.: always + */ +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, + EmberEUI64 newNodeEui64, + EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, + EmberJoinDecision decision) +{ +} + +/** @brief Trust Center Keepalive Abort + * + * This callback is called when the device should abort the trust center + * keepalive process. + * + */ +void emberAfTrustCenterKeepaliveAbortCallback(void) +{ +} + +/** @brief Trust Center Keepalive Update + * + * This callback is called when the device finishes registration (successfully + * or otherwise) and the trust center keepalive process must be updated. If the + * keepalive process has not been started, then it is started. Otherwise if the + * keepalive is in the process of searching for the TC, it will process the + * result of that Trust Center search operation. + * + * @param registrationComplete Ver.: always + */ +void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete) +{ +} + +/** @brief Unused Pan Id Found + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application of the PAN id and channel found following a call to + * ::emberScanForUnusedPanId(). See form-and-join documentation for more + * information. + * + * @param panId Ver.: always + * @param channel Ver.: always + */ +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, + uint8_t channel) +{ +} + +/** @brief Write Attributes Response + * + * This function is called by the application framework when a Write Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of write attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen) +{ + return false; +} + +/** @brief Zigbee Key Establishment + * + * A callback to the application to notify it of the status of the request for a + * Link Key. + * + * @param partner partner The IEEE address of the partner device. Or all zeros + * if the Key establishment failed. Ver.: always + * @param status The status of the key establishment. Ver.: always + */ +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, + EmberKeyStatus status) +{ +} + +/** + * @brief Called whenever the radio is powered off. + */ +void halRadioPowerDownHandler(void) +{ +} + + +/** + * @brief Called whenever the radio is powered on. + */ +void halRadioPowerUpHandler(void) +{ +} + +/** + * @brief Called whenever the microcontroller enters/exits a idle/sleep mode + * + * @param enter True if entering idle/sleep, False if exiting + * @param sleepMode Idle/sleep mode + */ +void halSleepCallback(boolean enter, SleepModes sleepMode) +{ +} diff --git a/examples/wifi-echo/server/esp32/main/gen/callback.h b/examples/wifi-echo/server/esp32/main/gen/callback.h new file mode 100644 index 00000000000000..0d72b17d7c6a35 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/callback.h @@ -0,0 +1,26485 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_CALLBACK_PROTOTYPES +#define SILABS_EMBER_AF_CALLBACK_PROTOTYPES + + +/** + * @addtogroup callback Application Framework callback interface Reference + * This header provides callback function prototypes to interface the + * developer's application code with the Ember Application Framework. + * @{ + */ + + +#include "app/framework/include/af-types.h" +#include "hal/hal.h" +#include EMBER_AF_API_NETWORK_STEERING + + + + +/** @name Non-Cluster Related Callbacks */ +// @{ +/** @brief Add To Current App Tasks + * + * This function is only useful to sleepy end devices. This function will note + * the passed item as part of a set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Until the + * outstanding task is completed, the device may poll more frequently and sleep + * less often. + * + * @param tasks Ver.: always + */ +void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks); +/** @brief Allow Network Write Attribute + * + * This function is called by the application framework before it writes an + * attribute in response to a write attribute request from an external device. + * The value passed into this callback is the value to which the attribute is to + * be set by the framework. + Example: In mirroring simple metering data + * on an Energy Services Interface (ESI) (formerly called Energy Service Portal + * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only + * attributes on its mirror. The-meter-mirror sample application, located in + * app/framework/sample-apps, uses this callback to allow the mirrored device to + * write simple metering attributes on the mirror regardless of the fact that + * most simple metering attributes are defined as read-only by the ZigBee + * specification. + Note: The ZCL specification does not (as of this + * writing) specify any permission-level security for writing writeable + * attributes. As far as the ZCL specification is concerned, if an attribute is + * writeable, any device that has a link key for the device should be able to + * write that attribute. Furthermore if an attribute is read only, it should not + * be written over the air. Thus, if you implement permissions for writing + * attributes as a feature, you MAY be operating outside the specification. This + * is unlikely to be a problem for writing read-only attributes, but it may be a + * problem for attributes that are writeable according to the specification but + * restricted by the application implementing this callback. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param value Ver.: always + * @param type Ver.: always + */ +EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t* value, + uint8_t type); +/** @brief Attribute Read Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute read. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeReadAccessCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint16_t manufacturerCode, + uint16_t attributeId); +/** @brief Attribute Write Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute write. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + uint16_t manufacturerCode, + uint16_t attributeId); +/** @brief Clear Report Table + * + * This function is called by the framework when the application should clear + * the report table. + * + */ +EmberStatus emberAfClearReportTableCallback(void); +/** @brief Cluster Init + * + * This function is called when a specific cluster is initialized. It gives the + * application an opportunity to take care of cluster initialization procedures. + * It is called exactly once for each endpoint where cluster is present. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + */ +void emberAfClusterInitCallback(uint8_t endpoint, + EmberAfClusterId clusterId); +/** @brief Cluster Security Custom + * + * This callback is fired when determining if APS encryption is required for a + * cluster outside of the specification's required clusters. In other words, + * for the Smart Energy profile this would be a cluster beyond the list that + * normally requires APS encryption. + * + * @param profileId The profile ID Ver.: always + * @param clusterId The cluster ID Ver.: always + * @param incoming Whether this is an incoming or outgoing message. Ver.: + * always + * @param commandId The ZCL command ID being sent/received. Ver.: always + */ +bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, + EmberAfClusterId clusterId, + bool incoming, + uint8_t commandId); +/** @brief Configure Reporting Command + * + * This function is called by the application framework when a Configure + * Reporting command is received from an external device. The Configure + * Reporting command contains a series of attribute reporting configuration + * records. The application should return true if the message was processed or + * false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd); +/** @brief Configure Reporting Response + * + * This function is called by the application framework when a Configure + * Reporting Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute status records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen); +/** @brief Default Response + * + * This function is called by the application framework when a Default Response + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param commandId The command identifier to which this is a response. Ver.: + * always + * @param status Specifies either SUCCESS or the nature of the error that was + * detected in the received command. Ver.: always + */ +bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, + uint8_t commandId, + EmberAfStatus status); +/** @brief Discover Attributes Response + * + * This function is called by the application framework when a Discover + * Attributes Response or Discover Attributes Extended Response command is + * received from an external device. The Discover Attributes Response command + * contains a bool indicating if discovery is complete and a list of zero or + * more attribute identifier/type records. The final argument indicates whether + * the response is in the extended format or not. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param discoveryComplete Indicates whether there are more attributes to be + * discovered. true if there are no more attributes to be discovered. Ver.: + * always + * @param buffer Buffer containing the list of attribute identifier/type + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + * @param extended Indicates whether the response is in the extended format or + * not. Ver.: always + */ +bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, + bool discoveryComplete, + uint8_t *buffer, + uint16_t bufLen, + bool extended); +/** @brief Discover Commands Generated Response + * + * This function is called by the framework when Discover Commands Generated + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, + uint16_t manufacturerCode, + bool discoveryComplete, + uint8_t *commandIds, + uint16_t commandIdCount); +/** @brief Discover Commands Received Response + * + * This function is called by the framework when Discover Commands Received + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, + uint16_t manufacturerCode, + bool discoveryComplete, + uint8_t *commandIds, + uint16_t commandIdCount); +/** @brief Eeprom Init + * + * Tells the system to initialize the EEPROM if it is not already initialized. + * + */ +void emberAfEepromInitCallback(void); +/** @brief Eeprom Note Initialized State + * + * Records the state of the EEPROM so that an intelligent driver (like the + * EEPROM plugin) can re-initialize the driver prior to any calls to it. + * + * @param state The state of the EEPROM, false=re-initalization needed, + * true=no-re-init needed Ver.: always + */ +void emberAfEepromNoteInitializedStateCallback(bool state); +/** @brief Eeprom Shutdown + * + * Tells the system to shutdown the EEPROM if it is not already shutdown. + * + */ +void emberAfEepromShutdownCallback(void); +/** @brief Energy Scan Result + * + * This is called by the low-level stack code when an 802.15.4 energy scan + * completes. + * + * @param channel The channel where the energy scan took place. Ver.: always + * @param rssi The receive signal strength indicator for the channel. Ver.: + * always + */ +void emberAfEnergyScanResultCallback(uint8_t channel, + int8_t rssi); +/** @brief External Attribute Read + * + * Like emberAfExternalAttributeWriteCallback above, this function is called + * when the framework needs to read an attribute that is not stored within the + * Application Framework's data structures. + All of the important + * information about the attribute itself is passed as a pointer to an + * EmberAfAttributeMetadata struct, which is stored within the application and + * used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h + This function assumes that the + * application is able to read the attribute, write it into the passed buffer, + * and return immediately. Any attributes that require a state machine for + * reading and writing are not really candidates for externalization at the + * present time. The Application Framework does not currently include a state + * machine for reading or writing attributes that must take place across a + * series of application ticks. Attributes that cannot be read in a timely + * manner should be stored within the Application Framework and updated + * occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * read the attribute and write it into the passed buffer, it should return a + * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally + * managed attribute value is smaller than what the buffer can hold. In the case + * of a buffer overflow throw an appropriate error such as + * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the + * application was not able to read the attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + * @param maxReadLength Ver.: always + */ +EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *attributeMetadata, + uint16_t manufacturerCode, + uint8_t *buffer, + uint16_t maxReadLength); +/** @brief External Attribute Write + * + * This function is called whenever the Application Framework needs to write an + * attribute which is not stored within the data structures of the Application + * Framework itself. One of the new features in Version 2 is the ability to + * store attributes outside the Framework. This is particularly useful for + * attributes that do not need to be stored because they can be read off the + * hardware when they are needed, or are stored in some central location used by + * many modules within the system. In this case, you can indicate that the + * attribute is stored externally. When the framework needs to write an external + * attribute, it makes a call to this callback. + This callback is very + * useful for host micros which need to store attributes in persistent memory. + * Because each host micro (used with an Ember NCP) has its own type of + * persistent memory storage, the Application Framework does not include the + * ability to mark attributes as stored in flash the way that it does for Ember + * SoCs like the EM35x. On a host micro, any attributes that need to be stored + * in persistent memory should be marked as external and accessed through the + * external read and write callbacks. Any host code associated with the + * persistent storage should be implemented within this callback. + All of + * the important information about the attribute itself is passed as a pointer + * to an EmberAfAttributeMetadata struct, which is stored within the application + * and used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h. + This function assumes that the + * application is able to write the attribute and return immediately. Any + * attributes that require a state machine for reading and writing are not + * candidates for externalization at the present time. The Application Framework + * does not currently include a state machine for reading or writing attributes + * that must take place across a series of application ticks. Attributes that + * cannot be written immediately should be stored within the Application + * Framework and updated occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any + * other return value indicates the application was not able to write the + * attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + */ +EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeMetadata *attributeMetadata, + uint16_t manufacturerCode, + uint8_t *buffer); +/** @brief Find Unused Pan Id And Form + * + * This function is called by the framework to search for an unused PAN id and + * form a new network. The application should return EMBER_SUCCESS if the + * operation was initiated successfully. + * + */ +EmberStatus emberAfFindUnusedPanIdAndFormCallback(void); +/** @brief Get Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * return the set of tasks the application has outstanding. These tasks affect + * how the application behaves with regard to sleeping and polling. + * + */ +EmberAfApplicationTask emberAfGetCurrentAppTasksCallback(void); +/** @brief Get Current Poll Control + * + * This function will retrieve the current poll control that the system is using + * for the current network. This is determined by examining all the scheduled + * events and obtaining the most restrictive poll control context across all + * events. The most restrictive poll control is EMBER_AF_SHORT_POLL followed by + * EMBER_AF_LONG_POLL. + * + */ +EmberAfEventPollControl emberAfGetCurrentPollControlCallback(void); +/** @brief Get Current Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * current poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalMsCallback(void); +/** @brief Get Current Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * current poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalQsCallback(void); +/** @brief Get Current Sleep Control + * + * This function will retrieve the current sleep control that the system is + * using. This is determined by examining all the scheduled events and + * obtaining the most restrictive sleep control context across all events. The + * most restrictive sleep control is EMBER_AF_STAY_AWAKE followed by + * EMBER_AF_OK_TO_SLEEP. + * + */ +EmberAfEventSleepControl emberAfGetCurrentSleepControlCallback(void); +/** @brief Get Current Time + * + * This callback is called when device attempts to get current time from the + * hardware. If this device has means to retrieve exact time, then this method + * should implement it. If the callback can't provide the exact time it should + * return 0 to indicate failure. Default action is to return 0, which indicates + * that device does not have access to real time. + * + */ +uint32_t emberAfGetCurrentTimeCallback(void); +/** @brief Get Default Poll Control + * + * This function will retrieve the default poll control for the current network + * as previously set by emberAfSetDefaultPollControlCallback(). The default + * poll control will limit whether the network can long poll. + * + */ +EmberAfEventPollControl emberAfGetDefaultPollControlCallback(void); +/** @brief Get Default Sleep Control + * + * This function will retrieve the default sleep control the system is using as + * previously set by emberAfSetDefaultSleepControlCallback(). The default sleep + * control will limit whether the device can sleep. + * + */ +EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void); +/** @brief Get Endpoint By Index + * + * Get the endpoint number based on the passed index. By default the framework + * handles this by managing endpoints based on the precompiled configuration + * defined in AppBuilder. This callback can override this behavior at runtime + * and provide additional endpoints or different data than the compiled values. + * If the index is overridden than the callback shall return true and set the + * endpointReturn parameter accordingly. A value of 0xFF means the endpoint + * doesn't exist at that index. + Otherwise false must be returned by the + * callback and the default framework behavior will be executed. This is only + * applicable to the SOC devices. + * + * @param index The index of the endpoint. Ver.: always + * @param endpointReturn The value of endpoint. Ver.: always + */ +bool emberAfGetEndpointByIndexCallback(uint8_t index, + uint8_t* endpointReturn); +/** @brief Get Endpoint Description + * + * This callback is called by the framework whenever it receives a ZDO request + * to enumerate the details about an endpoint. By default the framework + * provides the information based on the precompiled endpoint information as + * defined in AppBuilder. This callback can override that behavior at runtime + * and return different information. If the endpoint information is being + * overridden then the callback must return true. Otherwise it should return + * false, which allows the framework to perform its default behavior. This is + * only applicable to SOC devices. + * + * @param endpoint The endpoint number that is being queried. Ver.: always + * @param result This is a pointer to a data structure where the endpoint + * information is written if the callback is providing the information. Ver.: + * always + */ +bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, + EmberEndpointDescription* result); +/** @brief Get Endpoint Info + * + * This function is a callback to an application implemented endpoint that + * operates outside the normal application framework. When the framework wishes + * to perform operations with that endpoint it uses this callback to retrieve + * the endpoint's information. If the endpoint exists and the application can + * provide data then true shall be returned. Otherwise the callback must return + * false. + * + * @param endpoint The endpoint to retrieve data for. Ver.: always + * @param returnNetworkIndex The index corresponding to the ZigBee network the + * endpoint belongs to. If not using a multi-network device, 0 must be + * returned. Otherwise on a multi-network device the stack will switch to this + * network before sending the message. Ver.: always + * @param returnEndpointInfo A pointer to a data struct that will be written + * with information about the endpoint. Ver.: always + */ +bool emberAfGetEndpointInfoCallback(uint8_t endpoint, + uint8_t* returnNetworkIndex, + EmberAfEndpointInfoStruct* returnEndpointInfo); +/** @brief Get Form And Join Extended Pan Id + * + * This callback is called by the framework to get the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param resultLocation Ver.: always + */ +void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t *resultLocation); +/** @brief Get Long Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * long poll interval (in milliseconds) for the current network. This interval + * is the maximum amount of time a child will wait between polls of its parent + * when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalMsCallback(void); +/** @brief Get Long Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * long poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalQsCallback(void); +/** @brief Get Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in milliseconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalMsCallback(void); +/** @brief Get Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in quarter seconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalQsCallback(void); +/** @brief Get Source Route Overhead + * + * This function is called by the framework to determine the overhead required + * in the network frame for source routing to a particular destination. + * + * @param destination The node id of the destination Ver.: always + */ +uint8_t emberAfGetSourceRouteOverheadCallback(EmberNodeId destination); +/** @brief Get Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout bitmask for the current network. The bitmask + * determines which tasks will timeout automatically and which tasks require + * manual removal from the task list. + * + */ +EmberAfApplicationTask emberAfGetWakeTimeoutBitmaskCallback(void); +/** @brief Get Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in milliseconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutMsCallback(void); +/** @brief Get Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in quarter seconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutQsCallback(void); +/** @brief Hal Button Isr + * + * This callback is called by the framework whenever a button is pressed on the + * device. This callback is called within ISR context. + * + * @param button The button which has changed state, either BUTTON0 or BUTTON1 + * as defined in the appropriate BOARD_HEADER. Ver.: always + * @param state The new state of the button referenced by the button parameter, + * either ::BUTTON_PRESSED if the button has been pressed or ::BUTTON_RELEASED + * if the button has been released. Ver.: always + */ +void emberAfHalButtonIsrCallback(uint8_t button, + uint8_t state); +/** @brief Incoming Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack receives a packet from one of the + * protocol layers specified in ::EmberZigbeePacketType. + + The packetType + * argument is one of the values of the ::EmberZigbeePacketType enum. If the + * stack receives an 802.15.4 MAC beacon, it will call this function with the + * packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + The + * implementation of this callback may alter the data contained in packetData, + * modify options and flags in the auxillary data, or consume the packet itself, + * either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, + uint8_t* packetData, + uint8_t* size_p, + void* data); +/** @brief Initiate Inter Pan Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device on a different PAN. The application should return + * EMBER_SUCCESS if key establishment was initiated successfully. The + * application should call ::emberAfInterPanKeyEstablishmentCallback as events + * occur. + * + * @param panId The PAN id of the remote device. Ver.: always + * @param eui64 The EUI64 of the remote device. Ver.: always + */ +EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, + const EmberEUI64 eui64); +/** @brief Initiate Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device. The application should return EMBER_SUCCESS if key + * establishment was initiated successfully. The application should call + * ::emberAfKeyEstablishmentCallback as events occur. + * + * @param nodeId The node id of the remote device. Ver.: always + * @param endpoint The endpoint on the remote device. Ver.: always + */ +EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, + uint8_t endpoint); +/** @brief Initiate Partner Link Key Exchange + * + * This function is called by the framework to initiate a partner link key + * exchange with a remote device. The application should return EMBER_SUCCESS + * if the partner link key exchange was initiated successfully. When the + * partner link key exchange completes, the application should call the given + * callback. + * + * @param target The node id of the remote device. Ver.: always + * @param endpoint The key establishment endpoint of the remote device. Ver.: + * always + * @param callback The callback that should be called when the partner link key + * exchange completse. Ver.: always + */ +EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, + uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback *callback); +/** @brief Inter Pan Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param panId Ver.: always + * @param eui64 Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, + bool amInitiator, + EmberPanId panId, + const EmberEUI64 eui64, + uint8_t delayInSeconds); +/** @brief Interpan Send Message + * + * This function will send a raw MAC message with interpan frame format using + * the passed parameters. + * + * @param header Interpan header info Ver.: always + * @param messageLength The length of the message received or to send Ver.: + * always + * @param message The message data received or to send. Ver.: always + */ +EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, + uint16_t messageLength, + uint8_t* message); +/** @brief Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param partnerShortId Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, + bool amInitiator, + EmberNodeId partnerShortId, + uint8_t delayInSeconds); +/** @brief Main Init + * + * This function is called from the application's main function. It gives the + * application a chance to do any initialization required at system startup. Any + * code that you would normally put into the top of the application's main() + * routine should be put into this function. This is called before the clusters, + * plugins, and the network are initialized so some functionality is not yet + * available. + Note: No callback in the Application Framework is + * associated with resource cleanup. If you are implementing your application on + * a Unix host where resource cleanup is a consideration, we expect that you + * will use the standard Posix system calls, including the use of atexit() and + * handlers for signals such as SIGTERM, SIGINT, SIGCHLD, SIGPIPE and so on. If + * you use the signal() function to register your signal handler, please mind + * the returned value which may be an Application Framework function. If the + * return value is non-null, please make sure that you call the returned + * function from your handler to avoid negating the resource cleanup of the + * Application Framework itself. + * + */ +void emberAfMainInitCallback(void); +/** @brief Main Start + * + * This function is called at the start of main after the HAL has been + * initialized. The standard main function arguments of argc and argv are + * passed in. However not all platforms have support for main() function + * arguments. Those that do not are passed NULL for argv, therefore argv should + * be checked for NULL before using it. If the callback determines that the + * program must exit, it should return true. The value returned by main() will + * be the value written to the returnCode pointer. Otherwise the callback + * should return false to let normal execution continue. + * + * @param returnCode Ver.: always + * @param argc Ver.: always + * @param argv Ver.: always + */ +bool emberAfMainStartCallback(int* returnCode, + int argc, + char** argv); +/** @brief Main Tick + * + * Whenever main application tick is called, this callback will be called at the + * end of the main tick execution. + * + */ +void emberAfMainTickCallback(void); +/** @brief Mark Buffers + * + * This function is called when the garbage collector runs. Any buffers held by + * the application must be marked. + * + */ +void emberAfMarkBuffersCallback(void); +/** @brief Message Sent + * + * This function is called by the application framework from the message sent + * handler, when it is informed by the stack regarding the message sent status. + * All of the values passed to the emberMessageSentHandler are passed on to this + * callback. This provides an opportunity for the application to verify that its + * message has been sent successfully and take the appropriate action. This + * callback should return a bool value of true or false. A value of true + * indicates that the message sent notification has been handled and should not + * be handled by the application framework. + * + * @param type Ver.: always + * @param indexOrDestination Ver.: always + * @param apsFrame Ver.: always + * @param msgLen Ver.: always + * @param message Ver.: always + * @param status Ver.: always + */ +bool emberAfMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame* apsFrame, + uint16_t msgLen, + uint8_t* message, + EmberStatus status); +/** @brief Ncp Init + * + * This function is called when the network coprocessor is being initialized, + * either at startup or upon reset. It provides applications on opportunity to + * perform additional configuration of the NCP. The function is always called + * twice when the NCP is initialized. In the first invocation, memoryAllocation + * will be true and the application should only issue EZSP commands that affect + * memory allocation on the NCP. For example, tables on the NCP can be resized + * in the first call. In the second invocation, memoryAllocation will be false + * and the application should only issue EZSP commands that do not affect memory + * allocation. For example, tables on the NCP can be populated in the second + * call. This callback is not called on SoCs. + * + * @param memoryAllocation Ver.: always + */ +void emberAfNcpInitCallback(bool memoryAllocation); +/** @brief Ncp Is Awake Isr + * + * This function is called IN ISR CONTEXT. It notes that the NCP is awake after + * sleeping. Care should be taken to do minimal processing in this ISR handler + * function. + * + */ +void emberAfNcpIsAwakeIsrCallback(void); +/** @brief Network Found + * + * This callback is generated when an active scan finds a 802.15.4 network. + * + * @param networkFound A struct containing information about the network found. + * Ver.: always + * @param lqi The link quality indication of the network found. Ver.: always + * @param rssi The received signal strength indication of the network found. + * Ver.: always + */ +void emberAfNetworkFoundCallback(EmberZigbeeNetwork* networkFound, + uint8_t lqi, + int8_t rssi); +/** @brief Network Key Update Complete + * + * This is called by the framework when a network key update operation started + * by the trust center is complete. + * + * @param status Ver.: always + */ +void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status); +/** @brief Ota Bootload + * + * The platform specific routine to bootload the device from a ZigBee + * over-the-air upgrade file. + * + * @param id A pointer to the structure that contains the information about what + * OTA image to bootload. Ver.: always + * @param ncpUpgradeTagId The tag ID of the upgrade data that will be used to + * bootload the device. Ver.: always + */ +uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, + uint16_t ncpUpgradeTagId); +/** @brief Ota Client Bootload + * + * This callback is fired when the OTA Client recevies a command to bootload the + * newly downloaded OTA image. This callback will perform the platform specific + * to bootload their device. + * + * @param id This is the identifier relating to the image that has been + * downloaded and is ready for bootload. Ver.: always + */ +void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id); +/** @brief Ota Client Custom Verify + * + * This callback is executed by the OTA client after the signature verification + * has successfully completed. It allows the device to do its own custom + * verification of the image (such as verifying that the EBL is intact). + * + * @param newVerification This indicates if a new verification should be + * started. Ver.: always + * @param id This is ID of the image to be verified. Ver.: always + */ +EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, + const EmberAfOtaImageId* id); +/** @brief Ota Client Download Complete + * + * This callback indicates that the OTA client has completed the download of a + * file. If the file has been completely downloaded and cryptographic checks + * have been turned on, then those will be performed prior to this callback and + * that outcome included in the 'success' result. On failure, this callback is + * merely informative, and the return type is ignored. On succesful download, + * this callback allows the client to perform any additional verification of the + * downloaded image and return that result to the OTA server. + * + * @param success This indicates the success or failure of the download and + * cryptographic verification process (if applicable). Ver.: always + * @param id This is the image identifier information that corresponds to the + * download result. Ver.: always + */ +bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, + const EmberAfOtaImageId* id); +/** @brief Ota Client Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster client. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand *message); +/** @brief Ota Client Start + * + * This callback should be called when the profile specific registration has + * completed successfully. It will start the client's state machine that will + * find the OTA server, query it for the next image, download the image, wait + * for the bootload message, and kick off the bootload. + * + */ +void emberAfOtaClientStartCallback(void); +/** @brief Ota Client Version Info + * + * This function is called by the OTA client when a new query will occur to the + * server asking what the next version of firmware is. The client can inform + * the cluster software as to what information to use in the query (and + * subsequent download). + * + * @param currentImageInfo This is the information to use in the next query by + * the client cluster code. It contains the manufacturer ID, image type ID, and + * the firmware version to be specified in the query message sent to the server. + * Ver.: always + * @param hardwareVersion This is a pointer to the hardware version to use in + * the query. If no hardware version should be used, then + * EMBER_AF_INVALID_HARDWARE_VERSION should be used. Ver.: always + */ +void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId* currentImageInfo, + uint16_t* hardwareVersion); +/** @brief Ota Page Request Server Policy + * + * This callback is called by the OTA server page request code when it wants to + * determine if it is allowed for an OTA client to make a page request. It is + * only called if page request support has been enabled on the server. It + * should return EMBER_ZCL_STATUS_SUCCESS if it allows the page request, and + * EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND if it does not want to allow it. + * + */ +uint8_t emberAfOtaPageRequestServerPolicyCallback(void); +/** @brief Ota Server Block Size + * + * This function provides a way for the server to adjust the block size of its + * response to an Image block request by a client. + * + * @param clientNodeId The node Id of OTA client making an image block request. + * Ver.: always + */ +uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId); +/** @brief Ota Server Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster server. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message); +/** @brief Ota Server Query + * + * This callback is fired when the OTA server receives a query request by the + * client. The callback lets the server application indicate to the client what + * the 'next' version of software is for the device, or if there is not one + * available. + * + * @param currentImageId This is the current software image that the client + * hase. Ver.: always + * @param hardwareVersion If this value is non-NULL, it indicates the hardware + * version of the client device. If NULL, the client did not specify a hardware + * version. Ver.: always + * @param nextUpgradeImageId This is a pointer to a data structure containing + * the 'next' software version for the client to download. Ver.: always + */ +uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, + uint16_t* hardwareVersion, + EmberAfOtaImageId* nextUpgradeImageId); +/** @brief Ota Server Send Image Notify + * + * This callback is an indication to the OTA server that it should send out + * notification about an OTA file that is available for download. + * + * @param dest The destination of the image notify message. May be a broadcast + * address. Ver.: always + * @param endpoint The destination endpoint of the image notify message. May be + * a broadcast endpoint. Ver.: always + * @param payloadType The type of data the image notify message will contain. 0 + * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. + * 3 = Manufacturer ID, image type ID, and firmware version. Ver.: always + * @param queryJitter The percentage of nodes that should respond to this + * message, from 1-100. On receipt of this message, each recipient will + * randomly choose a percentage and only query the server if their percentage is + * below this value. Ver.: always + * @param id The image information that will be put in the message. The data + * within this struct that will be appended to the message is determined by the + * previous 'payloadType' argument. Ver.: always + */ +bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, + uint8_t endpoint, + uint8_t payloadType, + uint8_t queryJitter, + const EmberAfOtaImageId* id); +/** @brief Ota Server Upgrade End Request + * + * This function is called when the OTA server receives a request an upgrade end + * request. If the request indicated a successful download by the client, the + * server must tell the client when and if to upgrade to the downloaded image. + * + * @param source The node ID of the device that sent the upgrade end request. + * Ver.: always + * @param status This is the ZCL status sent by the client indicating the result + * of its attempt to download the new upgrade image. If the status is not + * EMBER_ZCL_STATUS_SUCCESS then this callback is merely informative and no + * response mesasge will be generated by the server. Ver.: always + * @param returnValue If the server returns true indicating that the client + * should apply the upgrade, this time value indicates when in the future the + * client should apply the upgrade. Ver.: always + * @param imageId This variable indicates the software version that the client + * successfully downloaded and is asking to upgrade to. Ver.: always + */ +bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, + uint8_t status, + uint32_t* returnValue, + const EmberAfOtaImageId* imageId); +/** @brief Ota Storage Check Temp Data + * + * This callback will validate temporary data in the storage device to determine + * whether it is a complete file, a partially downloaded file, or there is no + * file present. When a complete or partial file is found it will return + * EMBER_AF_OTA_STORAGE_SUCCESS or EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND, + * respectively. In that case, the currentOffset, totalImageSize, and + * newFileInfo will be populated with data. When EMBER_AF_OTA_STORAGE_ERROR is + * returned, no temporary data is present. + * + * @param currentOffset A pointer to a value that will be written with the + * offset within the total file size that has been successfully stored in the + * storage device. This will indicate how much data has been currently + * dowloaded. Ver.: always + * @param totalImageSize A pointer to a value that will be written with the + * total image size of the OTA file when a download has completed. This does + * not indicate how much data has actually been downloaded currently. Ver.: + * always + * @param newFileInfo This is the image id of the temporary file data stored in + * the storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t* currentOffset, + uint32_t* totalImageSize, + EmberAfOtaImageId* newFileInfo); +/** @brief Ota Storage Clear Temp Data + * + * This function clears any existing temp data that was downloaed. It is used + * immediately prior to downloading a raw image over the air. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageClearTempDataCallback(void); +/** @brief Ota Storage Close + * + * This callback shuts down the ZigBee Over-the-air storage module. + * + */ +void emberAfOtaStorageCloseCallback(void); +/** @brief Ota Storage Driver Download Finish + * + * This callback defines the low-level means by which a device records the final + * offset value of the download image. + * + * @param offset The value of the final offset of the image download. Ver.: + * always + */ +void emberAfOtaStorageDriverDownloadFinishCallback(uint32_t offset); +/** @brief Ota Storage Driver Init + * + * The initialization code for the OTA storage driver. + * + */ +bool emberAfOtaStorageDriverInitCallback(void); +/** @brief Ota Storage Driver Invalidate Image + * + * This callback invalidates the image stored on disk so that it will not be + * bootloaded, and it will not be a valid image that is in the middle of + * downloading. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverInvalidateImageCallback(void); +/** @brief Ota Storage Driver Prepare To Resume Download + * + * This callback allows the underlying storage driver to prepare to resume the + * OTA file download. For example, the driver may exceute a page erase to + * insure the next page is ready to be written to. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(void); +/** @brief Ota Storage Driver Read + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param offset The address offset from the start of the storage device where + * data is to be read. Ver.: always + * @param length The length of the data to be read from the storage device. + * Ver.: always + * @param returnData A pointer where the data read from the device should be + * written to. Ver.: always + */ +bool emberAfOtaStorageDriverReadCallback(uint32_t offset, + uint32_t length, + uint8_t* returnData); +/** @brief Ota Storage Driver Retrieve Last Stored Offset + * + * This callback defines the low-level means by which a device retrieves the + * last persistently recorded download offset. This may be different than last + * actual download offset. + * + */ +uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void); +/** @brief Ota Storage Driver Write + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param dataToWrite A pointer to the data that will be written to the storage + * device. Ver.: always + * @param offset The address offset from the start of the storage device where + * data will be written. Ver.: always + * @param length The length of the data to be written to the storage device. + * Ver.: always + */ +bool emberAfOtaStorageDriverWriteCallback(const uint8_t* dataToWrite, + uint32_t offset, + uint32_t length); +/** @brief Ota Storage Finish Download + * + * This function indicates to the storage module that the download has finished. + * + * @param offset The final offset of the downloaded file (i.e. the total size) + * Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset); +/** @brief Ota Storage Get Count + * + * This callback returns the total number of ZigBee Over-the-air upgrade images + * stored in the storage module. + * + */ +uint8_t emberAfOtaStorageGetCountCallback(void); +/** @brief Ota Storage Get Full Header + * + * This callback populates the EmberAfOtaHeader structure pointed to by the + * returnData with data about the OTA file stored in the storage module. + * + * @param id This is a pointer to the image id for the OTA file to retrieve + * information about. Ver.: always + * @param returnData This is a pointer to the location of the structure that + * will be populated with data. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId* id, + EmberAfOtaHeader* returnData); +/** @brief Ota Storage Get Total Image Size + * + * This function returns the total size of the ZigBee Over-the-air file with the + * passed parameters. If no file is found with those parameters, 0 is returned. + * + * @param id A pointer to the image identifier for the OTA file to retrieve + * information for. Ver.: always + */ +uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId* id); +/** @brief Ota Storage Init + * + * This callback initializes the ZigBee Over-the-air storage module. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageInitCallback(void); +/** @brief Ota Storage Iterator First + * + * This callback lets you walk through the list of all OTA files by jumping to + * the first file in the list maintained by the storage module. If there is no + * file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorFirstCallback(void); +/** @brief Ota Storage Iterator Next + * + * This callback lets you walk through the list of all OTA files by jumping to + * the next file in the list maintained by the storage module. If there is no + * next file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void); +/** @brief Ota Storage Read Image Data + * + * This callback reads data from the specified OTA file and returns that data to + * the caller. + * + * @param id This is a pointer to the image id for the OTA file to retrieve data + * from. Ver.: always + * @param offset This is the offset relative to the start of the image where the + * data should be read from. Ver.: always + * @param length This is the length of data that will be read. Ver.: always + * @param returnData This is a pointer to where the data read out of the file + * will be written to Ver.: always + * @param returnedLength This is a pointer to a variable where the actual length + * of data read will be written to. A short read may occur if the end of file + * was reached. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId* id, + uint32_t offset, + uint32_t length, + uint8_t* returnData, + uint32_t* returnedLength); +/** @brief Ota Storage Search + * + * This callback searches through the list of all images for one that matches + * the passed parameters. On success an image identifier is returned with a + * matching image. On failure emberAfInvalidImageId is returned. + * + * @param manufacturerId The ZigBee assigned identifier of the manufacturer + * contained in the OTA image being searched for. Ver.: always + * @param imageTypeId The image type identifier contained in the OTA image being + * searched for. Ver.: always + * @param hardwareVersion This is a pointer to the hardware version that will be + * used in the search. If the pointer is NULL, hardware version will not be + * considered when searching for matching images. If it points to a value, the + * search will only consider images where that value falls between the minimum + * and maxmimum hardware version specified in the OTA file. If no hardware + * version is present in an OTA file but the other parameters match, the file + * will be considered a match Ver.: always + */ +EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, + uint16_t imageTypeId, + const uint16_t* hardwareVersion); +/** @brief Ota Storage Write Temp Data + * + * This function writes to the temporary data in the storage device at the + * specified offset. It is used when downloading a raw image over the air. + * + * @param offset The location within the download image file where to write the + * data. Ver.: always + * @param length The length of data to write. Ver.: always + * @param data A pointer to the temporary data that will be written to the + * storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, + uint32_t length, + const uint8_t* data); +/** @brief Outgoing Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack prepares to send a packet from one + * of the protocol layers specified in ::EmberZigbeePacketType. + + The + * packetType argument is one of the values of the ::EmberZigbeePacketType enum. + * If the stack receives an 802.15.4 MAC beacon, it will call this function with + * the packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + + * The implementation of this callback may alter the data contained in + * packetData, modify options and flags in the auxillary data, or consume the + * packet itself, either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, + uint8_t* packetData, + uint8_t* size_p, + void* data); +/** @brief Partner Link Key Exchange Request + * + * This function is called by the framework on SOC platforms when a remote node + * requests a partner link key exchange. The application should return + * EMBER_SUCCESS to accept the request or any other status to reject it. On + * network coprocessor platforms, this function will not be called because the + * NCP handles partner link key exchange requests based on the binding policy. + * + * @param partner The EUI of the remote node. Ver.: always + */ +EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner); +/** @brief Partner Link Key Exchange Response + * + * This function is called by the framework when a remote node requests a + * partner link key exchange. The application should return true to accept the + * request or false to reject it. On network coprocessor platforms, this + * function will not be called because the NCP handles partner link key exchange + * requests based on the binding policy. + * + * @param sender The EUI of the remote node. Ver.: always + * @param status The ZDO response status. Ver.: always + */ +void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, + EmberZdoStatus status); +/** @brief Performing Key Establishment + * + * This function is called by the framework to determine if the device is + * performing key establishment. The application should return true if key + * establishment is in progress. + * + */ +bool emberAfPerformingKeyEstablishmentCallback(void); +/** @brief Post Attribute Change + * + * This function is called by the application framework after it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute was set by the framework. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +void emberAfPostAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t type, + uint8_t size, + uint8_t* value); +/** @brief Post Em4 Reset + * + * A callback called by application framework, and implemented by em4 plugin + * + */ +void emberAfPostEm4ResetCallback(void); +/** @brief Pre Attribute Change + * + * This function is called by the application framework before it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute is to be set by the framework. The application should return + * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus + * to reject it. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + uint8_t type, + uint8_t size, + uint8_t* value); +/** @brief Pre Cli Send + * + * This function is called by the framework when it is about to pass a message + * constructed over CLI to the stack primitives for sending. If the function + * returns true it is assumed that the callback has consumed and processed the + * message. The framework will not do any further processing on the message. + + * If the function returns false then it is assumed that the callback has + * not processed the message and the framework will continue to process + * accordingly. + * + * @param apsFrame The structure containing the APS frame Ver.: always + * @param source Source Node Id Ver.: always + * @param destination Destintion Node Id Ver.: always + * @param message Pointer to the message payload Ver.: always + * @param messageLength Length of the message payload Ver.: always + */ +bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, + EmberNodeId source, + EmberNodeId destination, + uint8_t* message, + uint16_t messageLength); +/** @brief Pre Command Received + * + * This callback is the second in the Application Framework's message processing + * chain. At this point in the processing of incoming over-the-air messages, the + * application has determined that the incoming message is a ZCL command. It + * parses enough of the message to populate an EmberAfClusterCommand struct. The + * Application Framework defines this struct value in a local scope to the + * command processing but also makes it available through a global pointer + * called emberAfCurrentCommand, in app/framework/util/util.c. When command + * processing is complete, this pointer is cleared. + * + * @param cmd Ver.: always + */ +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); +/** @brief Pre Message Received + * + * This callback is the first in the Application Framework's message processing + * chain. The Application Framework calls it when a message has been received + * over the air but has not yet been parsed by the ZCL command-handling code. If + * you wish to parse some messages that are completely outside the ZCL + * specification or are not handled by the Application Framework's command + * handling code, you should intercept them for parsing in this callback. + + * This callback returns a Boolean value indicating whether or not the message + * has been handled. If the callback returns a value of true, then the + * Application Framework assumes that the message has been handled and it does + * nothing else with it. If the callback returns a value of false, then the + * application framework continues to process the message as it would with any + * incoming message. + Note: This callback receives a pointer to an + * incoming message struct. This struct allows the application framework to + * provide a unified interface between both Host devices, which receive their + * message through the ezspIncomingMessageHandler, and SoC devices, which + * receive their message through emberIncomingMessageHandler. + * + * @param incomingMessage Ver.: always + */ +bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage); +/** @brief Pre Message Send + * + * This function is called by the framework when it is about to pass a message + * to the stack primitives for sending. This message may or may not be ZCL, + * ZDO, or some other protocol. This is called prior to + any ZigBee + * fragmentation that may be done. If the function returns true it is assumed + * the callback has consumed and processed the message. The callback must also + * set the EmberStatus status code to be passed back to the caller. The + * framework will do no further processing on the message. + If the + * function returns false then it is assumed that the callback has not processed + * the mesasge and the framework will continue to process accordingly. + * + * @param messageStruct The structure containing the parameters of the APS + * message to be sent. Ver.: always + * @param status A pointer to the status code value that will be returned to the + * caller. Ver.: always + */ +bool emberAfPreMessageSendCallback(EmberAfMessageStruct* messageStruct, + EmberStatus* status); +/** @brief Pre Ncp Reset + * + * This function will be called prior to the reset of the NCP by the host. + * + */ +void emberAfPreNcpResetCallback(void); +/** @brief Pre ZDO Message Received + * + * This function passes the application an incoming ZDO message and gives the + * appictation the opportunity to handle it. By default, this callback returns + * false indicating that the incoming ZDO message has not been handled and + * should be handled by the Application Framework. + * + * @param emberNodeId Ver.: always + * @param apsFrame Ver.: always + * @param message Ver.: always + * @param length Ver.: always + */ +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, + EmberApsFrame* apsFrame, + uint8_t* message, + uint16_t length); +/** @brief Read Attributes Response + * + * This function is called by the application framework when a Read Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of read attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen); +/** @brief Read Reporting Configuration Command + * + * This function is called by the application framework when a Read Reporting + * Configuration command is received from an external device. The application + * should return true if the message was processed or false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand *cmd); +/** @brief Read Reporting Configuration Response + * + * This function is called by the application framework when a Read Reporting + * Configuration Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute reporting configuration + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen); +/** @brief Registration Abort + * + * This callback is called when the device should abort the registration + * process. + * + */ +void emberAfRegistrationAbortCallback(void); +/** @brief Registration + * + * This callback is called when the device joins a network and the process of + * registration is complete. This callback provides a success value of true if + * the registration process was successful and a value of false if registration + * failed. + * + * @param success true if registration succeeded, false otherwise. Ver.: always + */ +void emberAfRegistrationCallback(bool success); +/** @brief Registration Start + * + * This callback is called when the device joins a network and the registration + * process should begin. The application should return EMBER_SUCCESS if the + * registration process started successfully. When registration is complete, + * the application should call emberAfRegistrationCallback with an indication of + * success or failure. + * + */ +EmberStatus emberAfRegistrationStartCallback(void); +/** @brief Remote Delete Binding Permission + * + * This function is called by the framework to request permission to service the + * remote delete binding request. Return EMBER_SUCCESS to allow request, + * anything else to disallow request. + * + * @param index index to an Ember binding table entry Ver.: always + */ +EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index); +/** @brief Remote Set Binding Permission + * + * This function is called by the framework to request permission to service the + * remote set binding request. Return EMBER_SUCCESS to allow request, anything + * else to disallow request. + * + * @param entry Ember Binding Tablet Entry Ver.: always + */ +EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry *entry); +/** @brief Remove From Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * remove the passed item from the set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Removing the item + * from the list of outstanding tasks may allow the device to sleep longer and + * poll less frequently. If there are other outstanding tasks the system may + * still have to stay away and poll more often. + * + * @param tasks Ver.: always + */ +void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks); +/** @brief Report Attributes + * + * This function is called by the application framework when a Report Attributes + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this command. Ver.: always + * @param buffer Buffer containing the list of attribute report records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen); +/** @brief Reporting Attribute Change + * + * This function is called by the framework when an attribute managed by the + * framework changes. The application should call this function when an + * externally-managed attribute changes. The application should use the change + * notification to inform its reporting decisions. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param data Ver.: always + */ +void emberAfReportingAttributeChangeCallback(uint8_t endpoint, + EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, + uint8_t mask, + uint16_t manufacturerCode, + EmberAfAttributeType type, + uint8_t *data); +/** @brief Scan Complete + * + * This is called by the low-level stack code when an 802.15.4 active scan + * completes. + * + * @param channel If the status indicates an error, the channel on which the + * error occurred. Otherwise it is undefined for EMBER_SUCCESS. Ver.: always + * @param status The status of the scan. Ver.: always + */ +void emberAfScanCompleteCallback(uint8_t channel, + EmberStatus status); +/** @brief Scan Error + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application if an error occurs while scanning. See form-and-join + * documentation for more information. + * + * @param status The status of the scan. Ver.: always + */ +void emberAfScanErrorCallback(EmberStatus status); +/** @brief Security Init + * + * This callback is called by the framework to give the application a chance to + * modify the security settings of the node during network initialization. + * Depending on the context when this callback is called, the pointer to the + * initial security state may be NULL, which means the initial security state + * can no longer be modified as the node is already operating on the network. + * + * @param state Ver.: always + * @param extended Ver.: always + * @param trustCenter Ver.: always + */ +void emberAfSecurityInitCallback(EmberInitialSecurityState *state, + EmberExtendedSecurityBitmask *extended, + bool trustCenter); +/** @brief Set Default Poll Control + * + * This function will set the default poll control for the current network to + * control whether or not it can long poll. + * + * @param control Ver.: always + */ +void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control); +/** @brief Set Default Sleep Control + * + * This function will set the default behavior of a sleeping device to control + * whether or not it must stay awake. A device that stays awake does not sleep + * at all. Otherwise, the device can sleep between events when appropriate. + * + * @param control Ver.: always + */ +void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control); +/** @brief Set Form And Join Extended Pan Id + * + * This callback is called by the framework to set the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param extendedPanId Ver.: always + */ +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t *extendedPanId); +/** @brief Set Long Poll Interval Ms + * + * This function is only useful to end devices. This function will set the long + * poll interval (in milliseconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalMs Ver.: always + */ +void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs); +/** @brief Set Long Poll Interval Qs + * + * This function is only useful to end devices. This function will set the long + * poll interval (in quarter seconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalQs Ver.: always + */ +void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs); +/** @brief Set Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalMs Ver.: always + */ +void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs); +/** @brief Set Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalQs Ver.: always + */ +void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs); +/** @brief Set Source Route Overhead + * + * This function is called by the framework when it has information about the + * source route overhead to a particular destination. The application may use + * this information to cache the source route overhead. + * + * @param destination The node id of the destination Ver.: always + * @param overhead The overhead in bytes Ver.: always + */ +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, + uint8_t overhead); +/** @brief Set Time + * + * This callback should be implemented, if the device has access to real time + * clock, and has an ability to update that clock. The application framework + * expects to be passed the utcTime which is the number of seconds since the + * year 2000. Default implementation does nothing. Note: This function used to + * take time in year, month, day, hour, min, sec. We have changed this to + * utcTime in order to conserve code space. + * + * @param utcTime Ver.: always + */ +void emberAfSetTimeCallback(uint32_t utcTime); +/** @brief Set Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout bitmask for the current network. The bitmask determines + * which tasks will timeout automatically and which tasks require manual removal + * from the task list. + * + * @param tasks Ver.: always + */ +void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks); +/** @brief Set Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in milliseconds) for the current network. This timeout is + * the maximum amount of time a child will wait for a task in the wake bitmask + * to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutMs Ver.: always + */ +void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs); +/** @brief Set Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in quarter seconds) for the current network. This timeout + * is the maximum amount of time a child will wait for a task in the wake + * bitmask to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutQs Ver.: always + */ +void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs); +/** @brief Stack Status + * + * This function is called by the application framework from the stack status + * handler. This callbacks provides applications an opportunity to be notified + * of changes to the stack status and take appropriate action. The return code + * from this callback is ignored by the framework. The framework will always + * process the stack status after the callback returns. + * + * @param status Ver.: always + */ +bool emberAfStackStatusCallback(EmberStatus status); +/** @brief Start Move + * + * This function is called to initiate the process for a device to move (rejoin) + * to a new parent. + * + */ +bool emberAfStartMoveCallback(void); +/** @brief Start Search For Joinable Network + * + * This function is called by the framework to search for joinable networks and + * join a network. The application should return EMBER_SUCCESS if the operation + * was initiated successfully. + * + */ +EmberStatus emberAfStartSearchForJoinableNetworkCallback(void); +/** @brief Stop Move + * + * This function is called to cancel a previously scheduled move (rejoin) to a + * new parent. + * + */ +void emberAfStopMoveCallback(void); +/** @brief Trust Center Join + * + * This callback is called from within the application framework's + * implementation of emberTrustCenterJoinHandler or ezspTrustCenterJoinHandler. + * This callback provides the same arguments passed to the + * TrustCenterJoinHandler. For more information about the TrustCenterJoinHandler + * please see documentation included in stack/include/trust-center.h. + * + * @param newNodeId Ver.: always + * @param newNodeEui64 Ver.: always + * @param parentOfNewNode Ver.: always + * @param status Ver.: always + * @param decision Ver.: always + */ +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, + EmberEUI64 newNodeEui64, + EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, + EmberJoinDecision decision); +/** @brief Trust Center Keepalive Abort + * + * This callback is called when the device should abort the trust center + * keepalive process. + * + */ +void emberAfTrustCenterKeepaliveAbortCallback(void); +/** @brief Trust Center Keepalive Update + * + * This callback is called when the device finishes registration (successfully + * or otherwise) and the trust center keepalive process must be updated. If the + * keepalive process has not been started, then it is started. Otherwise if the + * keepalive is in the process of searching for the TC, it will process the + * result of that Trust Center search operation. + * + * @param registrationComplete Ver.: always + */ +void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete); +/** @brief Unused Pan Id Found + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application of the PAN id and channel found following a call to + * ::emberScanForUnusedPanId(). See form-and-join documentation for more + * information. + * + * @param panId Ver.: always + * @param channel Ver.: always + */ +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, + uint8_t channel); +/** @brief Write Attributes Response + * + * This function is called by the application framework when a Write Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of write attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, + uint8_t *buffer, + uint16_t bufLen); +/** @brief Zigbee Key Establishment + * + * A callback to the application to notify it of the status of the request for a + * Link Key. + * + * @param partner partner The IEEE address of the partner device. Or all zeros + * if the Key establishment failed. Ver.: always + * @param status The status of the key establishment. Ver.: always + */ +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, + EmberKeyStatus status); +/** @} END Non-Cluster Related Callbacks */ + +/** @name Basic Cluster Callbacks */ +// @{ + +/** @brief Basic Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBasicClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Basic Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBasicClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Basic Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBasicClusterClientInitCallback(uint8_t endpoint); +/** @brief Basic Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Basic Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Basic Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Basic Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBasicClusterClientTickCallback(uint8_t endpoint); +/** @brief Basic Cluster Get Locales Supported + * + * + * + * @param startLocale Ver.: always + * @param maxLocalesRequested Ver.: always + */ +bool emberAfBasicClusterGetLocalesSupportedCallback(uint8_t* startLocale, + uint8_t maxLocalesRequested); +/** @brief Basic Cluster Get Locales Supported Response + * + * + * + * @param discoveryComplete Ver.: always + * @param localeSupported Ver.: always + */ +bool emberAfBasicClusterGetLocalesSupportedResponseCallback(uint8_t discoveryComplete, + uint8_t* localeSupported); +/** @brief Basic Cluster Reset To Factory Defaults + * + * + * + */ +bool emberAfBasicClusterResetToFactoryDefaultsCallback(void); +/** @brief Basic Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBasicClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Basic Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBasicClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Basic Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBasicClusterServerInitCallback(uint8_t endpoint); +/** @brief Basic Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Basic Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Basic Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Basic Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBasicClusterServerTickCallback(uint8_t endpoint); + +/** @} END Basic Cluster Callbacks */ + +/** @name Power Configuration Cluster Callbacks */ +// @{ + +/** @brief Power Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerConfigClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Power Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerConfigClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Power Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Power Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Power Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerConfigClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Power Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerConfigClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Power Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Power Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Power Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Power Configuration Cluster Callbacks */ + +/** @name Device Temperature Configuration Cluster Callbacks */ +// @{ + +/** @brief Device Temperature Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceTempClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Device Temperature Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceTempClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Device Temperature Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceTempClusterClientInitCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceTempClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Temperature Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceTempClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Device Temperature Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceTempClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Device Temperature Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceTempClusterClientTickCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceTempClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Device Temperature Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceTempClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Device Temperature Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceTempClusterServerInitCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceTempClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Temperature Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceTempClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Device Temperature Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceTempClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Device Temperature Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceTempClusterServerTickCallback(uint8_t endpoint); + +/** @} END Device Temperature Configuration Cluster Callbacks */ + +/** @name Identify Cluster Callbacks */ +// @{ + +/** @brief Identify Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIdentifyClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Identify Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIdentifyClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Identify Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIdentifyClusterClientInitCallback(uint8_t endpoint); +/** @brief Identify Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Identify Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Identify Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Identify Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIdentifyClusterClientTickCallback(uint8_t endpoint); +/** @brief Identify Cluster E Z Mode Invoke + * + * + * + * @param action Ver.: always + */ +bool emberAfIdentifyClusterEZModeInvokeCallback(uint8_t action); +/** @brief Identify Cluster Identify + * + * + * + * @param identifyTime Ver.: always + */ +bool emberAfIdentifyClusterIdentifyCallback(uint16_t identifyTime); +/** @brief Identify Cluster Identify Query + * + * + * + */ +bool emberAfIdentifyClusterIdentifyQueryCallback(void); +/** @brief Identify Cluster Identify Query Response + * + * + * + * @param timeout Ver.: always + */ +bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout); +/** @brief Identify Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIdentifyClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Identify Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIdentifyClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Identify Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIdentifyClusterServerInitCallback(uint8_t endpoint); +/** @brief Identify Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Identify Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Identify Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Identify Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIdentifyClusterServerTickCallback(uint8_t endpoint); +/** @brief Identify Cluster Trigger Effect + * + * + * + * @param effectId Ver.: always + * @param effectVariant Ver.: always + */ +bool emberAfIdentifyClusterTriggerEffectCallback(uint8_t effectId, + uint8_t effectVariant); +/** @brief Identify Cluster Update Commission State + * + * + * + * @param action Ver.: always + * @param commissionStateMask Ver.: always + */ +bool emberAfIdentifyClusterUpdateCommissionStateCallback(uint8_t action, + uint8_t commissionStateMask); + +/** @} END Identify Cluster Callbacks */ + +/** @name Groups Cluster Callbacks */ +// @{ + +/** @brief Groups Cluster Clear Group Table + * + * This function is called by the framework when the application should clear + * the group table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint); +/** @brief Groups Cluster Endpoint In Group + * + * This function is called by the framework when it needs to determine if an + * endpoint is a member of a group. The application should return true if the + * endpoint is a member of the group and false otherwise. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + */ +bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, + uint16_t groupId); +/** @brief Groups Cluster Add Group + * + * + * + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, + uint8_t* groupName); +/** @brief Groups Cluster Add Group If Identifying + * + * + * + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, + uint8_t* groupName); +/** @brief Groups Cluster Add Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, + uint16_t groupId); +/** @brief Groups Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGroupsClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Groups Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGroupsClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Groups Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGroupsClusterClientInitCallback(uint8_t endpoint); +/** @brief Groups Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Groups Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Groups Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Groups Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGroupsClusterClientTickCallback(uint8_t endpoint); +/** @brief Groups Cluster Get Group Membership + * + * + * + * @param groupCount Ver.: always + * @param groupList Ver.: always + */ +bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount, + uint8_t* groupList); +/** @brief Groups Cluster Get Group Membership Response + * + * + * + * @param capacity Ver.: always + * @param groupCount Ver.: always + * @param groupList Ver.: always + */ +bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, + uint8_t groupCount, + uint8_t* groupList); +/** @brief Groups Cluster Remove All Groups + * + * + * + */ +bool emberAfGroupsClusterRemoveAllGroupsCallback(void); +/** @brief Groups Cluster Remove Group + * + * + * + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterRemoveGroupCallback(uint16_t groupId); +/** @brief Groups Cluster Remove Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, + uint16_t groupId); +/** @brief Groups Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGroupsClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Groups Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGroupsClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Groups Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGroupsClusterServerInitCallback(uint8_t endpoint); +/** @brief Groups Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Groups Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Groups Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Groups Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGroupsClusterServerTickCallback(uint8_t endpoint); +/** @brief Groups Cluster View Group + * + * + * + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterViewGroupCallback(uint16_t groupId); +/** @brief Groups Cluster View Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t* groupName); + +/** @} END Groups Cluster Callbacks */ + +/** @name Scenes Cluster Callbacks */ +// @{ + +/** @brief Scenes Cluster ClearSceneTable + * + * This function is called by the framework when the application should clear + * the scene table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint); +/** @brief Scenes Cluster Make Invalid + * + * This function is called to invalidate the valid attribute in the Scenes + * cluster. + * + * @param endpoint Ver.: always + */ +EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint); +/** @brief Scenes Cluster Recall Saved Scene + * + * This function is called by the framework when the application should recall a + * saved scene. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, + uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Remove Scenes In Group + * + * This function removes the scenes from a specified group. + * + * @param endpoint Endpoint Ver.: always + * @param groupId Group ID Ver.: always + */ +void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, + uint16_t groupId); +/** @brief Scenes Cluster Add Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, + uint8_t sceneId, + uint16_t transitionTime, + uint8_t* sceneName, + uint8_t* extensionFieldSets); +/** @brief Scenes Cluster Add Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfScenesClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Scenes Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfScenesClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Scenes Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfScenesClusterClientInitCallback(uint8_t endpoint); +/** @brief Scenes Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Scenes Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Scenes Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Scenes Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfScenesClusterClientTickCallback(uint8_t endpoint); +/** @brief Scenes Cluster Copy Scene + * + * + * + * @param mode Ver.: always + * @param groupIdFrom Ver.: always + * @param sceneIdFrom Ver.: always + * @param groupIdTo Ver.: always + * @param sceneIdTo Ver.: always + */ +bool emberAfScenesClusterCopySceneCallback(uint8_t mode, + uint16_t groupIdFrom, + uint8_t sceneIdFrom, + uint16_t groupIdTo, + uint8_t sceneIdTo); +/** @brief Scenes Cluster Copy Scene Response + * + * + * + * @param status Ver.: always + * @param groupIdFrom Ver.: always + * @param sceneIdFrom Ver.: always + */ +bool emberAfScenesClusterCopySceneResponseCallback(uint8_t status, + uint16_t groupIdFrom, + uint8_t sceneIdFrom); +/** @brief Scenes Cluster Enhanced Add Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterEnhancedAddSceneCallback(uint16_t groupId, + uint8_t sceneId, + uint16_t transitionTime, + uint8_t* sceneName, + uint8_t* extensionFieldSets); +/** @brief Scenes Cluster Enhanced Add Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterEnhancedAddSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Enhanced View Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterEnhancedViewSceneCallback(uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Enhanced View Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterEnhancedViewSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId, + uint16_t transitionTime, + uint8_t* sceneName, + uint8_t* extensionFieldSets); +/** @brief Scenes Cluster Get Scene Membership + * + * + * + * @param groupId Ver.: always + */ +bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId); +/** @brief Scenes Cluster Get Scene Membership Response + * + * + * + * @param status Ver.: always + * @param capacity Ver.: always + * @param groupId Ver.: always + * @param sceneCount Ver.: always + * @param sceneList Ver.: always + */ +bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, + uint8_t capacity, + uint16_t groupId, + uint8_t sceneCount, + uint8_t* sceneList); +/** @brief Scenes Cluster Recall Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: since zcl-7.0-07-5123-07 + */ +bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, + uint8_t sceneId, + uint16_t transitionTime); +/** @brief Scenes Cluster Remove All Scenes + * + * + * + * @param groupId Ver.: always + */ +bool emberAfScenesClusterRemoveAllScenesCallback(uint16_t groupId); +/** @brief Scenes Cluster Remove All Scenes Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, + uint16_t groupId); +/** @brief Scenes Cluster Remove Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Remove Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfScenesClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Scenes Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfScenesClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Scenes Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfScenesClusterServerInitCallback(uint8_t endpoint); +/** @brief Scenes Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Scenes Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Scenes Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Scenes Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfScenesClusterServerTickCallback(uint8_t endpoint); +/** @brief Scenes Cluster Store Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster Store Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster View Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, + uint8_t sceneId); +/** @brief Scenes Cluster View Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, + uint16_t groupId, + uint8_t sceneId, + uint16_t transitionTime, + uint8_t* sceneName, + uint8_t* extensionFieldSets); +/** @brief Scenes Cluster Store Current Scene + * + * This function is called by the framework when the application should store + * the current scene. If an entry already exists in the scene table with the + * same scene and group ids, the application should update the entry with the + * current scene. Otherwise, a new entry should be adde to the scene table, if + * possible. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, + uint16_t groupId, + uint8_t sceneId); + +/** @} END Scenes Cluster Callbacks */ + +/** @name On/off Cluster Callbacks */ +// @{ + +/** @brief On/off Cluster Level Control Effect + * + * This is called by the framework when the on/off cluster initiates a command + * that must effect a level control change. The implementation assumes that the + * client will handle any effect on the On/Off Cluster. + * + * @param endpoint Ver.: always + * @param newValue Ver.: always + */ +void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, + bool newValue); +/** @brief On/off Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief On/off Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief On/off Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffClusterClientInitCallback(uint8_t endpoint); +/** @brief On/off Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief On/off Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief On/off Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffClusterClientTickCallback(uint8_t endpoint); +/** @brief On/off Cluster Off + * + * + * + */ +bool emberAfOnOffClusterOffCallback(void); +/** @brief On/off Cluster Off With Effect + * + * + * + * @param effectId Ver.: always + * @param effectVariant Ver.: always + */ +bool emberAfOnOffClusterOffWithEffectCallback(uint8_t effectId, + uint8_t effectVariant); +/** @brief On/off Cluster On + * + * + * + */ +bool emberAfOnOffClusterOnCallback(void); +/** @brief On/off Cluster On With Recall Global Scene + * + * + * + */ +bool emberAfOnOffClusterOnWithRecallGlobalSceneCallback(void); +/** @brief On/off Cluster On With Timed Off + * + * + * + * @param onOffControl Ver.: always + * @param onTime Ver.: always + * @param offWaitTime Ver.: always + */ +bool emberAfOnOffClusterOnWithTimedOffCallback(uint8_t onOffControl, + uint16_t onTime, + uint16_t offWaitTime); +/** @brief On/off Cluster Sample Mfg Specific Off With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOffWithTransitionCallback(void); +/** @brief On/off Cluster Sample Mfg Specific On With Transition2 + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOnWithTransition2Callback(void); +/** @brief On/off Cluster Sample Mfg Specific On With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOnWithTransitionCallback(void); +/** @brief On/off Cluster Sample Mfg Specific Toggle With Transition2 + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransition2Callback(void); +/** @brief On/off Cluster Sample Mfg Specific Toggle With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransitionCallback(void); +/** @brief On/off Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief On/off Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief On/off Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffClusterServerInitCallback(uint8_t endpoint); +/** @brief On/off Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief On/off Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief On/off Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffClusterServerTickCallback(uint8_t endpoint); +/** @brief On/off Cluster Toggle + * + * + * + */ +bool emberAfOnOffClusterToggleCallback(void); +/** @brief On/off Cluster Set Value + * + * This function is called when the on/off value needs to be set, either through + * normal channels or as a result of a level change. + * + * @param endpoint Ver.: always + * @param command Ver.: always + * @param initiatedByLevelChange Ver.: always + */ +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, + uint8_t command, + bool initiatedByLevelChange); + +/** @} END On/off Cluster Callbacks */ + +/** @name On/off Switch Configuration Cluster Callbacks */ +// @{ + +/** @brief On/off Switch Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief On/off Switch Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief On/off Switch Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Switch Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief On/off Switch Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffSwitchConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief On/off Switch Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief On/off Switch Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief On/off Switch Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Switch Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief On/off Switch Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffSwitchConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief On/off Switch Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END On/off Switch Configuration Cluster Callbacks */ + +/** @name Level Control Cluster Callbacks */ +// @{ + +/** @brief Level Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLevelControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Level Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLevelControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Level Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLevelControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Level Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Level Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Level Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Level Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLevelControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Level Control Cluster Move + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, + uint8_t rate, + uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Move To Level + * + * + * + * @param level Ver.: always + * @param transitionTime Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, + uint16_t transitionTime, + uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Move To Level With On Off + * + * + * + * @param level Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, + uint16_t transitionTime); +/** @brief Level Control Cluster Move With On Off + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + */ +bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, + uint8_t rate); +/** @brief Level Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLevelControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Level Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLevelControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Level Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLevelControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Level Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Level Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Level Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Level Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLevelControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Level Control Cluster Step + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, + uint8_t stepSize, + uint16_t transitionTime, + uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Step With On Off + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, + uint8_t stepSize, + uint16_t transitionTime); +/** @brief Level Control Cluster Stop + * + * + * + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Stop With On Off + * + * + * + */ +bool emberAfLevelControlClusterStopWithOnOffCallback(void); + +/** @} END Level Control Cluster Callbacks */ + +/** @name Alarms Cluster Callbacks */ +// @{ + +/** @brief Alarms Cluster Alarm + * + * + * + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfAlarmClusterAlarmCallback(uint8_t alarmCode, + uint16_t clusterId); +/** @brief Alarms Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfAlarmClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Alarms Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfAlarmClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Alarms Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfAlarmClusterClientInitCallback(uint8_t endpoint); +/** @brief Alarms Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfAlarmClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Alarms Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfAlarmClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Alarms Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfAlarmClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Alarms Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfAlarmClusterClientTickCallback(uint8_t endpoint); +/** @brief Alarms Cluster Get Alarm + * + * + * + */ +bool emberAfAlarmClusterGetAlarmCallback(void); +/** @brief Alarms Cluster Get Alarm Response + * + * + * + * @param status Ver.: always + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + * @param timeStamp Ver.: always + */ +bool emberAfAlarmClusterGetAlarmResponseCallback(uint8_t status, + uint8_t alarmCode, + uint16_t clusterId, + uint32_t timeStamp); +/** @brief Alarms Cluster Reset Alarm + * + * + * + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfAlarmClusterResetAlarmCallback(uint8_t alarmCode, + uint16_t clusterId); +/** @brief Alarms Cluster Reset Alarm Log + * + * + * + */ +bool emberAfAlarmClusterResetAlarmLogCallback(void); +/** @brief Alarms Cluster Reset All Alarms + * + * + * + */ +bool emberAfAlarmClusterResetAllAlarmsCallback(void); +/** @brief Alarms Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfAlarmClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Alarms Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfAlarmClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Alarms Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfAlarmClusterServerInitCallback(uint8_t endpoint); +/** @brief Alarms Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfAlarmClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Alarms Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfAlarmClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Alarms Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfAlarmClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Alarms Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfAlarmClusterServerTickCallback(uint8_t endpoint); + +/** @} END Alarms Cluster Callbacks */ + +/** @name Time Cluster Callbacks */ +// @{ + +/** @brief Time Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTimeClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Time Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTimeClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Time Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTimeClusterClientInitCallback(uint8_t endpoint); +/** @brief Time Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTimeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Time Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTimeClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Time Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTimeClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Time Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTimeClusterClientTickCallback(uint8_t endpoint); +/** @brief Time Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTimeClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Time Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTimeClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Time Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTimeClusterServerInitCallback(uint8_t endpoint); +/** @brief Time Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTimeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Time Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTimeClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Time Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTimeClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Time Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTimeClusterServerTickCallback(uint8_t endpoint); + +/** @} END Time Cluster Callbacks */ + +/** @name RSSI Location Cluster Callbacks */ +// @{ + +/** @brief RSSI Location Cluster Anchor Node Announce + * + * + * + * @param anchorNodeIeeeAddress Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + */ +bool emberAfRssiLocationClusterAnchorNodeAnnounceCallback(uint8_t* anchorNodeIeeeAddress, + int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3); +/** @brief RSSI Location Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRssiLocationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief RSSI Location Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRssiLocationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief RSSI Location Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRssiLocationClusterClientInitCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRssiLocationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief RSSI Location Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRssiLocationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief RSSI Location Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRssiLocationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief RSSI Location Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRssiLocationClusterClientTickCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Compact Location Data Notification + * + * + * + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterCompactLocationDataNotificationCallback(uint8_t locationType, + int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3, + uint8_t qualityMeasure, + uint16_t locationAge); +/** @brief RSSI Location Cluster Device Configuration Response + * + * + * + * @param status Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param calculationPeriod Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param reportingPeriod Ver.: always + */ +bool emberAfRssiLocationClusterDeviceConfigurationResponseCallback(uint8_t status, + int16_t power, + uint16_t pathLossExponent, + uint16_t calculationPeriod, + uint8_t numberRssiMeasurements, + uint16_t reportingPeriod); +/** @brief RSSI Location Cluster Get Device Configuration + * + * + * + * @param targetAddress Ver.: always + */ +bool emberAfRssiLocationClusterGetDeviceConfigurationCallback(uint8_t* targetAddress); +/** @brief RSSI Location Cluster Get Location Data + * + * + * + * @param flags Ver.: always + * @param numberResponses Ver.: always + * @param targetAddress Ver.: always + */ +bool emberAfRssiLocationClusterGetLocationDataCallback(uint8_t flags, + uint8_t numberResponses, + uint8_t* targetAddress); +/** @brief RSSI Location Cluster Location Data Notification + * + * + * + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param locationMethod Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterLocationDataNotificationCallback(uint8_t locationType, + int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3, + int16_t power, + uint16_t pathLossExponent, + uint8_t locationMethod, + uint8_t qualityMeasure, + uint16_t locationAge); +/** @brief RSSI Location Cluster Location Data Response + * + * + * + * @param status Ver.: always + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param locationMethod Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterLocationDataResponseCallback(uint8_t status, + uint8_t locationType, + int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3, + int16_t power, + uint16_t pathLossExponent, + uint8_t locationMethod, + uint8_t qualityMeasure, + uint16_t locationAge); +/** @brief RSSI Location Cluster Report Rssi Measurements + * + * + * + * @param measuringDevice Ver.: always + * @param neighbors Ver.: always + * @param neighborsInfo Ver.: always + */ +bool emberAfRssiLocationClusterReportRssiMeasurementsCallback(uint8_t* measuringDevice, + uint8_t neighbors, + uint8_t* neighborsInfo); +/** @brief RSSI Location Cluster Request Own Location + * + * + * + * @param blindNode Ver.: always + */ +bool emberAfRssiLocationClusterRequestOwnLocationCallback(uint8_t* blindNode); +/** @brief RSSI Location Cluster Rssi Ping + * + * + * + * @param locationType Ver.: always + */ +bool emberAfRssiLocationClusterRssiPingCallback(uint8_t locationType); +/** @brief RSSI Location Cluster Rssi Request + * + * + * + */ +bool emberAfRssiLocationClusterRssiRequestCallback(void); +/** @brief RSSI Location Cluster Rssi Response + * + * + * + * @param replyingDevice Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param rssi Ver.: always + * @param numberRssiMeasurements Ver.: always + */ +bool emberAfRssiLocationClusterRssiResponseCallback(uint8_t* replyingDevice, + int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3, + int8_t rssi, + uint8_t numberRssiMeasurements); +/** @brief RSSI Location Cluster Send Pings + * + * + * + * @param targetAddress Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param calculationPeriod Ver.: always + */ +bool emberAfRssiLocationClusterSendPingsCallback(uint8_t* targetAddress, + uint8_t numberRssiMeasurements, + uint16_t calculationPeriod); +/** @brief RSSI Location Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRssiLocationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief RSSI Location Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRssiLocationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief RSSI Location Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRssiLocationClusterServerInitCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRssiLocationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief RSSI Location Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRssiLocationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief RSSI Location Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRssiLocationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief RSSI Location Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRssiLocationClusterServerTickCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Set Absolute Location + * + * + * + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + */ +bool emberAfRssiLocationClusterSetAbsoluteLocationCallback(int16_t coordinate1, + int16_t coordinate2, + int16_t coordinate3, + int16_t power, + uint16_t pathLossExponent); +/** @brief RSSI Location Cluster Set Device Configuration + * + * + * + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param calculationPeriod Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param reportingPeriod Ver.: always + */ +bool emberAfRssiLocationClusterSetDeviceConfigurationCallback(int16_t power, + uint16_t pathLossExponent, + uint16_t calculationPeriod, + uint8_t numberRssiMeasurements, + uint16_t reportingPeriod); + +/** @} END RSSI Location Cluster Callbacks */ + +/** @name Binary Input (Basic) Cluster Callbacks */ +// @{ + +/** @brief Binary Input (Basic) Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBinaryInputBasicClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Binary Input (Basic) Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBinaryInputBasicClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Binary Input (Basic) Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBinaryInputBasicClusterClientInitCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBinaryInputBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Binary Input (Basic) Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBinaryInputBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Binary Input (Basic) Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBinaryInputBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Binary Input (Basic) Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBinaryInputBasicClusterClientTickCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Binary Input (Basic) Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBinaryInputBasicClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Binary Input (Basic) Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBinaryInputBasicClusterServerInitCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBinaryInputBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Binary Input (Basic) Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBinaryInputBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Binary Input (Basic) Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBinaryInputBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Binary Input (Basic) Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBinaryInputBasicClusterServerTickCallback(uint8_t endpoint); + +/** @} END Binary Input (Basic) Cluster Callbacks */ + +/** @name Commissioning Cluster Callbacks */ +// @{ + +/** @brief Commissioning Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Commissioning Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Commissioning Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCommissioningClusterClientInitCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Commissioning Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Commissioning Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Commissioning Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCommissioningClusterClientTickCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Reset Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterResetStartupParametersCallback(uint8_t options, + uint8_t index); +/** @brief Commissioning Cluster Reset Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterResetStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Restart Device + * + * + * + * @param options Ver.: always + * @param delay Ver.: always + * @param jitter Ver.: always + */ +bool emberAfCommissioningClusterRestartDeviceCallback(uint8_t options, + uint8_t delay, + uint8_t jitter); +/** @brief Commissioning Cluster Restart Device Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterRestartDeviceResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Restore Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterRestoreStartupParametersCallback(uint8_t options, + uint8_t index); +/** @brief Commissioning Cluster Restore Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterRestoreStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Save Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterSaveStartupParametersCallback(uint8_t options, + uint8_t index); +/** @brief Commissioning Cluster Save Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterSaveStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Commissioning Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Commissioning Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCommissioningClusterServerInitCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Commissioning Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Commissioning Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Commissioning Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCommissioningClusterServerTickCallback(uint8_t endpoint); + +/** @} END Commissioning Cluster Callbacks */ + +/** @name Partition Cluster Callbacks */ +// @{ + +/** @brief Partition Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPartitionClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Partition Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPartitionClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Partition Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPartitionClusterClientInitCallback(uint8_t endpoint); +/** @brief Partition Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPartitionClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Partition Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPartitionClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Partition Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPartitionClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Partition Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPartitionClusterClientTickCallback(uint8_t endpoint); +/** @brief Partition Cluster Multiple Ack + * + * + * + * @param ackOptions Ver.: always + * @param firstFrameIdAndNackList Ver.: always + */ +bool emberAfPartitionClusterMultipleAckCallback(uint8_t ackOptions, + uint8_t* firstFrameIdAndNackList); +/** @brief Partition Cluster Read Handshake Param + * + * + * + * @param partitionedClusterId Ver.: always + * @param attributeList Ver.: always + */ +bool emberAfPartitionClusterReadHandshakeParamCallback(uint16_t partitionedClusterId, + uint8_t* attributeList); +/** @brief Partition Cluster Read Handshake Param Response + * + * + * + * @param partitionedClusterId Ver.: always + * @param readAttributeStatusRecords Ver.: always + */ +bool emberAfPartitionClusterReadHandshakeParamResponseCallback(uint16_t partitionedClusterId, + uint8_t* readAttributeStatusRecords); +/** @brief Partition Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPartitionClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Partition Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPartitionClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Partition Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPartitionClusterServerInitCallback(uint8_t endpoint); +/** @brief Partition Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPartitionClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Partition Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPartitionClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Partition Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPartitionClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Partition Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPartitionClusterServerTickCallback(uint8_t endpoint); +/** @brief Partition Cluster Transfer Partitioned Frame + * + * + * + * @param fragmentationOptions Ver.: always + * @param partitionedIndicatorAndFrame Ver.: always + */ +bool emberAfPartitionClusterTransferPartitionedFrameCallback(uint8_t fragmentationOptions, + uint8_t* partitionedIndicatorAndFrame); +/** @brief Partition Cluster Write Handshake Param + * + * + * + * @param partitionedClusterId Ver.: always + * @param writeAttributeRecords Ver.: always + */ +bool emberAfPartitionClusterWriteHandshakeParamCallback(uint16_t partitionedClusterId, + uint8_t* writeAttributeRecords); + +/** @} END Partition Cluster Callbacks */ + +/** @name Over the Air Bootloading Cluster Callbacks */ +// @{ + +/** @brief Over the Air Bootloading Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaBootloadClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Over the Air Bootloading Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaBootloadClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Over the Air Bootloading Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaBootloadClusterClientInitCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaBootloadClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Over the Air Bootloading Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaBootloadClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Over the Air Bootloading Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaBootloadClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Over the Air Bootloading Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaBootloadClusterClientTickCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaBootloadClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Over the Air Bootloading Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaBootloadClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Over the Air Bootloading Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaBootloadClusterServerInitCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaBootloadClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Over the Air Bootloading Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaBootloadClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Over the Air Bootloading Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaBootloadClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Over the Air Bootloading Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaBootloadClusterServerTickCallback(uint8_t endpoint); + +/** @} END Over the Air Bootloading Cluster Callbacks */ + +/** @name Power Profile Cluster Callbacks */ +// @{ + +/** @brief Power Profile Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerProfileClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Power Profile Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerProfileClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Power Profile Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerProfileClusterClientInitCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerProfileClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Profile Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerProfileClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Power Profile Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerProfileClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Power Profile Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerProfileClusterClientTickCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Energy Phases Schedule Notification + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleNotificationCallback(uint8_t powerProfileId, + uint8_t numOfScheduledPhases, + uint8_t* scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Energy Phases Schedule Response + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleResponseCallback(uint8_t powerProfileId, + uint8_t numOfScheduledPhases, + uint8_t* scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule State Notification + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateNotificationCallback(uint8_t powerProfileId, + uint8_t numOfScheduledPhases, + uint8_t* scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule State Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Energy Phases Schedule State Response + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateResponseCallback(uint8_t powerProfileId, + uint8_t numOfScheduledPhases, + uint8_t* scheduledPhases); +/** @brief Power Profile Cluster Get Overall Schedule Price + * + * + * + */ +bool emberAfPowerProfileClusterGetOverallSchedulePriceCallback(void); +/** @brief Power Profile Cluster Get Overall Schedule Price Response + * + * + * + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetOverallSchedulePriceResponseCallback(uint16_t currency, + uint32_t price, + uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Get Power Profile Price + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Get Power Profile Price Extended + * + * + * + * @param options Ver.: always + * @param powerProfileId Ver.: always + * @param powerProfileStartTime Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedCallback(uint8_t options, + uint8_t powerProfileId, + uint16_t powerProfileStartTime); +/** @brief Power Profile Cluster Get Power Profile Price Extended Response + * + * + * + * @param powerProfileId Ver.: always + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedResponseCallback(uint8_t powerProfileId, + uint16_t currency, + uint32_t price, + uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Get Power Profile Price Response + * + * + * + * @param powerProfileId Ver.: always + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceResponseCallback(uint8_t powerProfileId, + uint16_t currency, + uint32_t price, + uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Power Profile Notification + * + * + * + * @param totalProfileNum Ver.: always + * @param powerProfileId Ver.: always + * @param numOfTransferredPhases Ver.: always + * @param transferredPhases Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileNotificationCallback(uint8_t totalProfileNum, + uint8_t powerProfileId, + uint8_t numOfTransferredPhases, + uint8_t* transferredPhases); +/** @brief Power Profile Cluster Power Profile Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Power Profile Response + * + * + * + * @param totalProfileNum Ver.: always + * @param powerProfileId Ver.: always + * @param numOfTransferredPhases Ver.: always + * @param transferredPhases Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileResponseCallback(uint8_t totalProfileNum, + uint8_t powerProfileId, + uint8_t numOfTransferredPhases, + uint8_t* transferredPhases); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Notification + * + * + * + * @param powerProfileId Ver.: always + * @param startAfter Ver.: always + * @param stopBefore Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsNotificationCallback(uint8_t powerProfileId, + uint16_t startAfter, + uint16_t stopBefore); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Response + * + * + * + * @param powerProfileId Ver.: always + * @param startAfter Ver.: always + * @param stopBefore Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsResponseCallback(uint8_t powerProfileId, + uint16_t startAfter, + uint16_t stopBefore); +/** @brief Power Profile Cluster Power Profile State Request + * + * + * + */ +bool emberAfPowerProfileClusterPowerProfileStateRequestCallback(void); +/** @brief Power Profile Cluster Power Profile State Response + * + * + * + * @param powerProfileCount Ver.: always + * @param powerProfileRecords Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileStateResponseCallback(uint8_t powerProfileCount, + uint8_t* powerProfileRecords); +/** @brief Power Profile Cluster Power Profiles State Notification + * + * + * + * @param powerProfileCount Ver.: always + * @param powerProfileRecords Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfilesStateNotificationCallback(uint8_t powerProfileCount, + uint8_t* powerProfileRecords); +/** @brief Power Profile Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerProfileClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Power Profile Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerProfileClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Power Profile Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerProfileClusterServerInitCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerProfileClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Profile Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerProfileClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Power Profile Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerProfileClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Power Profile Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerProfileClusterServerTickCallback(uint8_t endpoint); + +/** @} END Power Profile Cluster Callbacks */ + +/** @name Appliance Control Cluster Callbacks */ +// @{ + +/** @brief Appliance Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Execution Of A Command + * + * + * + * @param commandId Ver.: always + */ +bool emberAfApplianceControlClusterExecutionOfACommandCallback(uint8_t commandId); +/** @brief Appliance Control Cluster Overload Pause + * + * + * + */ +bool emberAfApplianceControlClusterOverloadPauseCallback(void); +/** @brief Appliance Control Cluster Overload Pause Resume + * + * + * + */ +bool emberAfApplianceControlClusterOverloadPauseResumeCallback(void); +/** @brief Appliance Control Cluster Overload Warning + * + * + * + * @param warningEvent Ver.: always + */ +bool emberAfApplianceControlClusterOverloadWarningCallback(uint8_t warningEvent); +/** @brief Appliance Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Signal State + * + * + * + */ +bool emberAfApplianceControlClusterSignalStateCallback(void); +/** @brief Appliance Control Cluster Signal State Notification + * + * + * + * @param applianceStatus Ver.: always + * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always + * @param applianceStatus2 Ver.: always + */ +bool emberAfApplianceControlClusterSignalStateNotificationCallback(uint8_t applianceStatus, + uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); +/** @brief Appliance Control Cluster Signal State Response + * + * + * + * @param applianceStatus Ver.: always + * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always + * @param applianceStatus2 Ver.: always + */ +bool emberAfApplianceControlClusterSignalStateResponseCallback(uint8_t applianceStatus, + uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); +/** @brief Appliance Control Cluster Write Functions + * + * + * + * @param functionId Ver.: always + * @param functionDataType Ver.: always + * @param functionData Ver.: always + */ +bool emberAfApplianceControlClusterWriteFunctionsCallback(uint16_t functionId, + uint8_t functionDataType, + uint8_t* functionData); + +/** @} END Appliance Control Cluster Callbacks */ + +/** @name Poll Control Cluster Callbacks */ +// @{ + +/** @brief Poll Control Cluster Check In + * + * + * + */ +bool emberAfPollControlClusterCheckInCallback(void); +/** @brief Poll Control Cluster Check In Response + * + * + * + * @param startFastPolling Ver.: always + * @param fastPollTimeout Ver.: always + */ +bool emberAfPollControlClusterCheckInResponseCallback(uint8_t startFastPolling, + uint16_t fastPollTimeout); +/** @brief Poll Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPollControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Poll Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPollControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Poll Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPollControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPollControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Poll Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPollControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Poll Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPollControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Poll Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPollControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Fast Poll Stop + * + * + * + */ +bool emberAfPollControlClusterFastPollStopCallback(void); +/** @brief Poll Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Poll Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPollControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Poll Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPollControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPollControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Poll Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPollControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Poll Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Poll Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPollControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Set Long Poll Interval + * + * + * + * @param newLongPollInterval Ver.: always + */ +bool emberAfPollControlClusterSetLongPollIntervalCallback(uint32_t newLongPollInterval); +/** @brief Poll Control Cluster Set Short Poll Interval + * + * + * + * @param newShortPollInterval Ver.: always + */ +bool emberAfPollControlClusterSetShortPollIntervalCallback(uint16_t newShortPollInterval); + +/** @} END Poll Control Cluster Callbacks */ + +/** @name Green Power Cluster Callbacks */ +// @{ + +/** @brief Green Power Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGreenPowerClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Green Power Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGreenPowerClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Green Power Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGreenPowerClusterClientInitCallback(uint8_t endpoint); +/** @brief Green Power Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGreenPowerClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Green Power Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGreenPowerClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Green Power Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGreenPowerClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Green Power Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGreenPowerClusterClientTickCallback(uint8_t endpoint); +/** @brief Green Power Cluster Gp Commissioning Notification + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppLink Ver.: since gp-1.0-09-5499-24 + * @param mic Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpCommissioningNotificationCallback(uint16_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint32_t gpdSecurityFrameCounter, + uint8_t gpdCommandId, + uint8_t* gpdCommandPayload, + uint16_t gppShortAddress, + uint8_t gppLink, + uint32_t mic); +/** @brief Green Power Cluster Gp Notification + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param gpdEndpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppDistance Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpNotificationCallback(uint16_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t gpdEndpoint, + uint32_t gpdSecurityFrameCounter, + uint8_t gpdCommandId, + uint8_t* gpdCommandPayload, + uint16_t gppShortAddress, + uint8_t gppDistance); +/** @brief Green Power Cluster Gp Notification Response + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpNotificationResponseCallback(uint8_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint32_t gpdSecurityFrameCounter); +/** @brief Green Power Cluster Gp Pairing + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param sinkIeeeAddress Ver.: since gp-1.0-09-5499-24 + * @param sinkNwkAddress Ver.: since gp-1.0-09-5499-24 + * @param sinkGroupId Ver.: since gp-1.0-09-5499-24 + * @param deviceId Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdKey Ver.: since gp-1.0-09-5499-24 + * @param assignedAlias Ver.: since gp-1.0-09-5499-24 + * @param groupcastRadius Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpPairingCallback(uint32_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t* sinkIeeeAddress, + uint16_t sinkNwkAddress, + uint16_t sinkGroupId, + uint8_t deviceId, + uint32_t gpdSecurityFrameCounter, + uint8_t* gpdKey, + uint16_t assignedAlias, + uint8_t groupcastRadius); +/** @brief Green Power Cluster Gp Pairing Configuration + * + * + * + * @param actions Ver.: since gp-1.0-09-5499-24 + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param deviceId Ver.: since gp-1.0-09-5499-24 + * @param groupListCount Ver.: since gp-1.0-09-5499-24 + * @param groupList Ver.: since gp-1.0-09-5499-24 + * @param gpdAssignedAlias Ver.: since gp-1.0-09-5499-24 + * @param groupcastRadius Ver.: since gp-1.0-15-2014-05-CCB2180 + * @param securityOptions Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityKey Ver.: since gp-1.0-09-5499-24 + * @param numberOfPairedEndpoints Ver.: since gp-1.0-09-5499-24 + * @param pairedEndpoints Ver.: since gp-1.0-09-5499-24 + * @param applicationInformation Ver.: always + * @param manufacturerId Ver.: always + * @param modeId Ver.: always + * @param numberOfGpdCommands Ver.: always + * @param gpdCommandIdList Ver.: always + * @param clusterIdListCount Ver.: always + * @param clusterListServer Ver.: always + * @param clusterListClient Ver.: always + * @param switchInformationLength Ver.: always + * @param switchConfiguration Ver.: always + * @param currentContactStatus Ver.: always + * @param totalNumberOfReports Ver.: always + * @param numberOfReports Ver.: always + * @param reportDescriptor Ver.: always + */ +bool emberAfGreenPowerClusterGpPairingConfigurationCallback(uint8_t actions, + uint16_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t deviceId, + uint8_t groupListCount, + uint8_t* groupList, + uint16_t gpdAssignedAlias, + uint8_t groupcastRadius, + uint8_t securityOptions, + uint32_t gpdSecurityFrameCounter, + uint8_t* gpdSecurityKey, + uint8_t numberOfPairedEndpoints, + uint8_t* pairedEndpoints, + uint8_t applicationInformation, + uint16_t manufacturerId, + uint16_t modeId, + uint8_t numberOfGpdCommands, + uint8_t* gpdCommandIdList, + uint8_t clusterIdListCount, + uint8_t* clusterListServer, + uint8_t* clusterListClient, + uint8_t switchInformationLength, + uint8_t switchConfiguration, + uint8_t currentContactStatus, + uint8_t totalNumberOfReports, + uint8_t numberOfReports, + uint8_t* reportDescriptor); +/** @brief Green Power Cluster Gp Pairing Search + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: always + */ +bool emberAfGreenPowerClusterGpPairingSearchCallback(uint16_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint); +/** @brief Green Power Cluster Gp Proxy Commissioning Mode + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param commissioningWindow Ver.: since gp-1.0-15-02014-011 + * @param channel Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpProxyCommissioningModeCallback(uint8_t options, + uint16_t commissioningWindow, + uint8_t channel); +/** @brief Green Power Cluster Gp Proxy Table Request + * + * + * + * @param options Ver.: always + * @param gpdSrcId Ver.: always + * @param gpdIeee Ver.: always + * @param endpoint Ver.: always + * @param index Ver.: always + */ +bool emberAfGreenPowerClusterGpProxyTableRequestCallback(uint8_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t index); +/** @brief Green Power Cluster Gp Proxy Table Response + * + * + * + * @param status Ver.: always + * @param totalNumberOfNonEmptyProxyTableEntries Ver.: always + * @param startIndex Ver.: always + * @param entriesCount Ver.: always + * @param proxyTableEntries Ver.: always + */ +bool emberAfGreenPowerClusterGpProxyTableResponseCallback(uint8_t status, + uint8_t totalNumberOfNonEmptyProxyTableEntries, + uint8_t startIndex, + uint8_t entriesCount, + uint8_t* proxyTableEntries); +/** @brief Green Power Cluster Gp Response + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param tempMasterShortAddress Ver.: since gp-1.0-09-5499-24 + * @param tempMasterTxChannel Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: always + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: always + */ +bool emberAfGreenPowerClusterGpResponseCallback(uint8_t options, + uint16_t tempMasterShortAddress, + uint8_t tempMasterTxChannel, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t gpdCommandId, + uint8_t* gpdCommandPayload); +/** @brief Green Power Cluster Gp Sink Commissioning Mode + * + * + * + * @param options Ver.: always + * @param gpmAddrForSecurity Ver.: always + * @param gpmAddrForPairing Ver.: always + * @param sinkEndpoint Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkCommissioningModeCallback(uint8_t options, + uint16_t gpmAddrForSecurity, + uint16_t gpmAddrForPairing, + uint8_t sinkEndpoint); +/** @brief Green Power Cluster Gp Sink Table Request + * + * + * + * @param options Ver.: always + * @param gpdSrcId Ver.: always + * @param gpdIeee Ver.: always + * @param endpoint Ver.: always + * @param index Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkTableRequestCallback(uint8_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t index); +/** @brief Green Power Cluster Gp Sink Table Response + * + * + * + * @param status Ver.: always + * @param totalNumberofNonEmptySinkTableEntries Ver.: always + * @param startIndex Ver.: always + * @param sinkTableEntriesCount Ver.: always + * @param sinkTableEntries Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkTableResponseCallback(uint8_t status, + uint8_t totalNumberofNonEmptySinkTableEntries, + uint8_t startIndex, + uint8_t sinkTableEntriesCount, + uint8_t* sinkTableEntries); +/** @brief Green Power Cluster Gp Translation Table Request + * + * + * + * @param startIndex Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableRequestCallback(uint8_t startIndex); +/** @brief Green Power Cluster Gp Translation Table Response + * + * + * + * @param status Ver.: since gp-1.0-09-5499-24 + * @param options Ver.: since gp-1.0-09-5499-24 + * @param totalNumberOfEntries Ver.: since gp-1.0-09-5499-24 + * @param startIndex Ver.: since gp-1.0-09-5499-24 + * @param entriesCount Ver.: since gp-1.0-09-5499-24 + * @param translationTableList Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableResponseCallback(uint8_t status, + uint8_t options, + uint8_t totalNumberOfEntries, + uint8_t startIndex, + uint8_t entriesCount, + uint8_t* translationTableList); +/** @brief Green Power Cluster Gp Translation Table Update + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param translations Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableUpdateCallback(uint16_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint8_t* translations); +/** @brief Green Power Cluster Gp Tunneling Stop + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppDistance Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTunnelingStopCallback(uint8_t options, + uint32_t gpdSrcId, + uint8_t* gpdIeee, + uint8_t endpoint, + uint32_t gpdSecurityFrameCounter, + uint16_t gppShortAddress, + int8_t gppDistance); +/** @brief Green Power Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGreenPowerClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Green Power Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGreenPowerClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Green Power Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGreenPowerClusterServerInitCallback(uint8_t endpoint); +/** @brief Green Power Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGreenPowerClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Green Power Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGreenPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Green Power Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGreenPowerClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Green Power Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGreenPowerClusterServerTickCallback(uint8_t endpoint); + +/** @} END Green Power Cluster Callbacks */ + +/** @name Keep-Alive Cluster Callbacks */ +// @{ + +/** @brief Keep-Alive Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeepaliveClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Keep-Alive Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeepaliveClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Keep-Alive Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeepaliveClusterClientInitCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeepaliveClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Keep-Alive Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeepaliveClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Keep-Alive Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeepaliveClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Keep-Alive Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeepaliveClusterClientTickCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeepaliveClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Keep-Alive Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeepaliveClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Keep-Alive Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeepaliveClusterServerInitCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeepaliveClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Keep-Alive Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeepaliveClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Keep-Alive Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeepaliveClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Keep-Alive Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeepaliveClusterServerTickCallback(uint8_t endpoint); + +/** @} END Keep-Alive Cluster Callbacks */ + +/** @name Shade Configuration Cluster Callbacks */ +// @{ + +/** @brief Shade Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfShadeConfigClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Shade Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfShadeConfigClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Shade Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfShadeConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfShadeConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Shade Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfShadeConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Shade Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfShadeConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Shade Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfShadeConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfShadeConfigClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Shade Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfShadeConfigClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Shade Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfShadeConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfShadeConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Shade Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfShadeConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Shade Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfShadeConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Shade Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfShadeConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Shade Configuration Cluster Callbacks */ + +/** @name Door Lock Cluster Callbacks */ +// @{ + +/** @brief Door Lock Cluster Clear All Pins + * + * + * + */ +bool emberAfDoorLockClusterClearAllPinsCallback(void); +/** @brief Door Lock Cluster Clear All Pins Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear All Rfids + * + * + * + */ +bool emberAfDoorLockClusterClearAllRfidsCallback(void); +/** @brief Door Lock Cluster Clear All Rfids Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId); +/** @brief Door Lock Cluster Clear Holiday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearPinCallback(uint16_t userId); +/** @brief Door Lock Cluster Clear Pin Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId); +/** @brief Door Lock Cluster Clear Rfid Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, + uint16_t userId); +/** @brief Door Lock Cluster Clear Weekday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, + uint16_t userId); +/** @brief Door Lock Cluster Clear Yearday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDoorLockClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Door Lock Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDoorLockClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Door Lock Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDoorLockClusterClientInitCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Door Lock Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Door Lock Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Door Lock Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDoorLockClusterClientTickCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Get Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId); +/** @brief Door Lock Cluster Get Holiday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param status Ver.: always + * @param localStartTime Ver.: since ha-1.2-05-3520-29 + * @param localEndTime Ver.: since ha-1.2-05-3520-29 + * @param operatingModeDuringHoliday Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, + uint8_t status, + uint32_t localStartTime, + uint32_t localEndTime, + uint8_t operatingModeDuringHoliday); +/** @brief Door Lock Cluster Get Log Record + * + * + * + * @param logIndex Ver.: always + */ +bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex); +/** @brief Door Lock Cluster Get Log Record Response + * + * + * + * @param logEntryId Ver.: always + * @param timestamp Ver.: always + * @param eventType Ver.: always + * @param source Ver.: always + * @param eventIdOrAlarmCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, + uint32_t timestamp, + uint8_t eventType, + uint8_t source, + uint8_t eventIdOrAlarmCode, + uint16_t userId, + uint8_t* pin); +/** @brief Door Lock Cluster Get Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetPinCallback(uint16_t userId); +/** @brief Door Lock Cluster Get Pin Response + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, + uint8_t userStatus, + uint8_t userType, + uint8_t* pin); +/** @brief Door Lock Cluster Get Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId); +/** @brief Door Lock Cluster Get Rfid Response + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param rfid Ver.: always + */ +bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, + uint8_t userStatus, + uint8_t userType, + uint8_t* rfid); +/** @brief Door Lock Cluster Get User Status + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetUserStatusCallback(uint16_t userId); +/** @brief Door Lock Cluster Get User Status Response + * + * + * + * @param userId Ver.: always + * @param status Ver.: always + */ +bool emberAfDoorLockClusterGetUserStatusResponseCallback(uint16_t userId, + uint8_t status); +/** @brief Door Lock Cluster Get User Type + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId); +/** @brief Door Lock Cluster Get User Type Response + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + */ +bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, + uint8_t userType); +/** @brief Door Lock Cluster Get Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, + uint16_t userId); +/** @brief Door Lock Cluster Get Weekday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param status Ver.: always + * @param daysMask Ver.: since ha-1.2-05-3520-29 + * @param startHour Ver.: since ha-1.2-05-3520-29 + * @param startMinute Ver.: since ha-1.2-05-3520-29 + * @param endHour Ver.: since ha-1.2-05-3520-29 + * @param endMinute Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, + uint16_t userId, + uint8_t status, + uint8_t daysMask, + uint8_t startHour, + uint8_t startMinute, + uint8_t endHour, + uint8_t endMinute); +/** @brief Door Lock Cluster Get Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, + uint16_t userId); +/** @brief Door Lock Cluster Get Yearday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param status Ver.: always + * @param localStartTime Ver.: since ha-1.2-05-3520-29 + * @param localEndTime Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, + uint16_t userId, + uint8_t status, + uint32_t localStartTime, + uint32_t localEndTime); +/** @brief Door Lock Cluster Lock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterLockDoorCallback(uint8_t* PIN); +/** @brief Door Lock Cluster Lock Door Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Operation Event Notification + * + * + * + * @param source Ver.: always + * @param eventCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + * @param timeStamp Ver.: always + * @param data Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterOperationEventNotificationCallback(uint8_t source, + uint8_t eventCode, + uint16_t userId, + uint8_t* pin, + uint32_t timeStamp, + uint8_t* data); +/** @brief Door Lock Cluster Programming Event Notification + * + * + * + * @param source Ver.: always + * @param eventCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + * @param userType Ver.: always + * @param userStatus Ver.: always + * @param timeStamp Ver.: always + * @param data Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterProgrammingEventNotificationCallback(uint8_t source, + uint8_t eventCode, + uint16_t userId, + uint8_t* pin, + uint8_t userType, + uint8_t userStatus, + uint32_t timeStamp, + uint8_t* data); +/** @brief Door Lock Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Door Lock Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDoorLockClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Door Lock Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDoorLockClusterServerInitCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Door Lock Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Door Lock Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Door Lock Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDoorLockClusterServerTickCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Set Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param localStartTime Ver.: always + * @param localEndTime Ver.: always + * @param operatingModeDuringHoliday Ver.: always + */ +bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, + uint32_t localStartTime, + uint32_t localEndTime, + uint8_t operatingModeDuringHoliday); +/** @brief Door Lock Cluster Set Holiday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Pin + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, + uint8_t userStatus, + uint8_t userType, + uint8_t* pin); +/** @brief Door Lock Cluster Set Pin Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Rfid + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param id Ver.: always + */ +bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, + uint8_t userStatus, + uint8_t userType, + uint8_t* id); +/** @brief Door Lock Cluster Set Rfid Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set User Status + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + */ +bool emberAfDoorLockClusterSetUserStatusCallback(uint16_t userId, + uint8_t userStatus); +/** @brief Door Lock Cluster Set User Status Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetUserStatusResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set User Type + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + */ +bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, + uint8_t userType); +/** @brief Door Lock Cluster Set User Type Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param daysMask Ver.: always + * @param startHour Ver.: always + * @param startMinute Ver.: always + * @param endHour Ver.: always + * @param endMinute Ver.: always + */ +bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, + uint16_t userId, + uint8_t daysMask, + uint8_t startHour, + uint8_t startMinute, + uint8_t endHour, + uint8_t endMinute); +/** @brief Door Lock Cluster Set Weekday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param localStartTime Ver.: always + * @param localEndTime Ver.: always + */ +bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, + uint16_t userId, + uint32_t localStartTime, + uint32_t localEndTime); +/** @brief Door Lock Cluster Set Yearday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Toggle + * + * + * + * @param pin Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterToggleCallback(uint8_t* pin); +/** @brief Door Lock Cluster Toggle Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterToggleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Unlock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t* PIN); +/** @brief Door Lock Cluster Unlock Door Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Unlock With Timeout + * + * + * + * @param timeoutInSeconds Ver.: always + * @param pin Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, + uint8_t* pin); +/** @brief Door Lock Cluster Unlock With Timeout Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status); + +/** @} END Door Lock Cluster Callbacks */ + +/** @name Window Covering Cluster Callbacks */ +// @{ + +/** @brief Window Covering Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfWindowCoveringClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Window Covering Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfWindowCoveringClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Window Covering Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfWindowCoveringClusterClientInitCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfWindowCoveringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Window Covering Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfWindowCoveringClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Window Covering Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfWindowCoveringClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Window Covering Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfWindowCoveringClusterClientTickCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfWindowCoveringClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Window Covering Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfWindowCoveringClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Window Covering Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfWindowCoveringClusterServerInitCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfWindowCoveringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Window Covering Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfWindowCoveringClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Window Covering Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Window Covering Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfWindowCoveringClusterServerTickCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Window Covering Down Close + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringDownCloseCallback(void); +/** @brief Window Covering Cluster Window Covering Go To Lift Percentage + * + * + * + * @param percentageLiftValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToLiftPercentageCallback(uint8_t percentageLiftValue); +/** @brief Window Covering Cluster Window Covering Go To Lift Value + * + * + * + * @param liftValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToLiftValueCallback(uint16_t liftValue); +/** @brief Window Covering Cluster Window Covering Go To Tilt Percentage + * + * + * + * @param percentageTiltValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToTiltPercentageCallback(uint8_t percentageTiltValue); +/** @brief Window Covering Cluster Window Covering Go To Tilt Value + * + * + * + * @param tiltValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToTiltValueCallback(uint16_t tiltValue); +/** @brief Window Covering Cluster Window Covering Stop + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringStopCallback(void); +/** @brief Window Covering Cluster Window Covering Up Open + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringUpOpenCallback(void); + +/** @} END Window Covering Cluster Callbacks */ + +/** @name Barrier Control Cluster Callbacks */ +// @{ + +/** @brief Barrier Control Cluster Barrier Control Go To Percent + * + * + * + * @param percentOpen Ver.: always + */ +bool emberAfBarrierControlClusterBarrierControlGoToPercentCallback(uint8_t percentOpen); +/** @brief Barrier Control Cluster Barrier Control Stop + * + * + * + */ +bool emberAfBarrierControlClusterBarrierControlStopCallback(void); +/** @brief Barrier Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBarrierControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Barrier Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBarrierControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Barrier Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBarrierControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBarrierControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Barrier Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Barrier Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBarrierControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Barrier Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBarrierControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBarrierControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Barrier Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBarrierControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Barrier Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBarrierControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Barrier Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Barrier Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Barrier Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBarrierControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Barrier Control Cluster Callbacks */ + +/** @name Pump Configuration and Control Cluster Callbacks */ +// @{ + +/** @brief Pump Configuration and Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPumpConfigControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Pump Configuration and Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPumpConfigControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Pump Configuration and Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPumpConfigControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPumpConfigControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pump Configuration and Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPumpConfigControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Pump Configuration and Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPumpConfigControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Pump Configuration and Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPumpConfigControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPumpConfigControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Pump Configuration and Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPumpConfigControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Pump Configuration and Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPumpConfigControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPumpConfigControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pump Configuration and Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPumpConfigControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Pump Configuration and Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPumpConfigControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Pump Configuration and Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPumpConfigControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Pump Configuration and Control Cluster Callbacks */ + +/** @name Thermostat Cluster Callbacks */ +// @{ + +/** @brief Thermostat Cluster Clear Weekly Schedule + * + * + * + */ +bool emberAfThermostatClusterClearWeeklyScheduleCallback(void); +/** @brief Thermostat Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Thermostat Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Thermostat Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatClusterClientInitCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Thermostat Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Thermostat Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatClusterClientTickCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Current Weekly Schedule + * + * + * + * @param numberOfTransitionsForSequence Ver.: always + * @param dayOfWeekForSequence Ver.: always + * @param modeForSequence Ver.: always + * @param payload Ver.: always + */ +bool emberAfThermostatClusterCurrentWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, + uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, + uint8_t* payload); +/** @brief Thermostat Cluster Get Relay Status Log + * + * + * + */ +bool emberAfThermostatClusterGetRelayStatusLogCallback(void); +/** @brief Thermostat Cluster Get Weekly Schedule + * + * + * + * @param daysToReturn Ver.: always + * @param modeToReturn Ver.: always + */ +bool emberAfThermostatClusterGetWeeklyScheduleCallback(uint8_t daysToReturn, + uint8_t modeToReturn); +/** @brief Thermostat Cluster Relay Status Log + * + * + * + * @param timeOfDay Ver.: always + * @param relayStatus Ver.: always + * @param localTemperature Ver.: always + * @param humidityInPercentage Ver.: always + * @param setpoint Ver.: always + * @param unreadEntries Ver.: always + */ +bool emberAfThermostatClusterRelayStatusLogCallback(uint16_t timeOfDay, + uint16_t relayStatus, + int16_t localTemperature, + uint8_t humidityInPercentage, + int16_t setpoint, + uint16_t unreadEntries); +/** @brief Thermostat Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Thermostat Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Thermostat Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatClusterServerInitCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Thermostat Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Thermostat Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatClusterServerTickCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Set Weekly Schedule + * + * + * + * @param numberOfTransitionsForSequence Ver.: always + * @param dayOfWeekForSequence Ver.: always + * @param modeForSequence Ver.: always + * @param payload Ver.: always + */ +bool emberAfThermostatClusterSetWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, + uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, + uint8_t* payload); +/** @brief Thermostat Cluster Setpoint Raise Lower + * + * + * + * @param mode Ver.: always + * @param amount Ver.: always + */ +bool emberAfThermostatClusterSetpointRaiseLowerCallback(uint8_t mode, + int8_t amount); + +/** @} END Thermostat Cluster Callbacks */ + +/** @name Fan Control Cluster Callbacks */ +// @{ + +/** @brief Fan Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFanControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fan Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFanControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fan Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFanControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFanControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fan Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFanControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fan Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFanControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fan Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFanControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFanControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fan Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFanControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fan Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFanControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFanControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fan Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFanControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fan Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFanControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fan Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFanControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fan Control Cluster Callbacks */ + +/** @name Dehumidification Control Cluster Callbacks */ +// @{ + +/** @brief Dehumidification Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDehumidControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dehumidification Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDehumidControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Dehumidification Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDehumidControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDehumidControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dehumidification Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDehumidControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Dehumidification Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDehumidControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Dehumidification Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDehumidControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDehumidControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dehumidification Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDehumidControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Dehumidification Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDehumidControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDehumidControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dehumidification Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDehumidControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Dehumidification Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDehumidControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Dehumidification Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDehumidControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Dehumidification Control Cluster Callbacks */ + +/** @name Thermostat User Interface Configuration Cluster Callbacks */ +// @{ + +/** @brief Thermostat User Interface Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatUiConfigClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Thermostat User Interface Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatUiConfigClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Thermostat User Interface Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatUiConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatUiConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat User Interface Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatUiConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Thermostat User Interface Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatUiConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Thermostat User Interface Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatUiConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatUiConfigClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Thermostat User Interface Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatUiConfigClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Thermostat User Interface Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatUiConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatUiConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat User Interface Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatUiConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Thermostat User Interface Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatUiConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Thermostat User Interface Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatUiConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Thermostat User Interface Configuration Cluster Callbacks */ + +/** @name Color Control Cluster Callbacks */ +// @{ + +/** @brief Color Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfColorControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Color Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfColorControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Color Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfColorControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Color Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Color Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Color Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Color Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfColorControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Color Control Cluster Color Loop Set + * + * + * + * @param updateFlags Ver.: always + * @param action Ver.: always + * @param direction Ver.: always + * @param time Ver.: always + * @param startHue Ver.: always + */ +bool emberAfColorControlClusterColorLoopSetCallback(uint8_t updateFlags, + uint8_t action, + uint8_t direction, + uint16_t time, + uint16_t startHue); +/** @brief Color Control Cluster Enhanced Move Hue + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveHueCallback(uint8_t moveMode, + uint16_t rate); +/** @brief Color Control Cluster Enhanced Move To Hue And Saturation + * + * + * + * @param enhancedHue Ver.: always + * @param saturation Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveToHueAndSaturationCallback(uint16_t enhancedHue, + uint8_t saturation, + uint16_t transitionTime); +/** @brief Color Control Cluster Enhanced Move To Hue + * + * + * + * @param enhancedHue Ver.: always + * @param direction Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveToHueCallback(uint16_t enhancedHue, + uint8_t direction, + uint16_t transitionTime); +/** @brief Color Control Cluster Enhanced Step Hue + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedStepHueCallback(uint8_t stepMode, + uint16_t stepSize, + uint16_t transitionTime); +/** @brief Color Control Cluster Move Color + * + * + * + * @param rateX Ver.: always + * @param rateY Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, + int16_t rateY, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move Color Temperature + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param colorTemperatureMinimum Ver.: always + * @param colorTemperatureMaximum Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, + uint16_t rate, + uint16_t colorTemperatureMinimum, + uint16_t colorTemperatureMaximum, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move Hue + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, + uint8_t rate, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move Saturation + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, + uint8_t rate, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Color + * + * + * + * @param colorX Ver.: always + * @param colorY Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, + uint16_t colorY, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Color Temperature + * + * + * + * @param colorTemperature Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Hue And Saturation + * + * + * + * @param hue Ver.: always + * @param saturation Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, + uint8_t saturation, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Hue + * + * + * + * @param hue Ver.: always + * @param direction Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, + uint8_t direction, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Saturation + * + * + * + * @param saturation Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfColorControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Color Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfColorControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Color Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfColorControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Color Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Color Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Color Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Color Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfColorControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Color Control Cluster Step Color + * + * + * + * @param stepX Ver.: always + * @param stepY Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepColorCallback(int16_t stepX, + int16_t stepY, + uint16_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Step Color Temperature + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param colorTemperatureMinimum Ver.: always + * @param colorTemperatureMaximum Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, + uint16_t stepSize, + uint16_t transitionTime, + uint16_t colorTemperatureMinimum, + uint16_t colorTemperatureMaximum, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Step Hue + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, + uint8_t stepSize, + uint8_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Step Saturation + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, + uint8_t stepSize, + uint8_t transitionTime, + uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Stop Move Step + * + * + * + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, + uint8_t optionsOverride); + +/** @} END Color Control Cluster Callbacks */ + +/** @name Ballast Configuration Cluster Callbacks */ +// @{ + +/** @brief Ballast Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBallastConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ballast Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBallastConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ballast Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBallastConfigurationClusterClientInitCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBallastConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ballast Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBallastConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ballast Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBallastConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ballast Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBallastConfigurationClusterClientTickCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBallastConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ballast Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBallastConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ballast Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBallastConfigurationClusterServerInitCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBallastConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ballast Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBallastConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ballast Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBallastConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ballast Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBallastConfigurationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ballast Configuration Cluster Callbacks */ + +/** @name Illuminance Measurement Cluster Callbacks */ +// @{ + +/** @brief Illuminance Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Illuminance Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Illuminance Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Illuminance Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Illuminance Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Illuminance Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Illuminance Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Illuminance Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Illuminance Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Illuminance Measurement Cluster Callbacks */ + +/** @name Illuminance Level Sensing Cluster Callbacks */ +// @{ + +/** @brief Illuminance Level Sensing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumLevelSensingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Illuminance Level Sensing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumLevelSensingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Illuminance Level Sensing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumLevelSensingClusterClientInitCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumLevelSensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Level Sensing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumLevelSensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Illuminance Level Sensing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumLevelSensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Illuminance Level Sensing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumLevelSensingClusterClientTickCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumLevelSensingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Illuminance Level Sensing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumLevelSensingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Illuminance Level Sensing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumLevelSensingClusterServerInitCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumLevelSensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Level Sensing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumLevelSensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Illuminance Level Sensing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumLevelSensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Illuminance Level Sensing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumLevelSensingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Illuminance Level Sensing Cluster Callbacks */ + +/** @name Temperature Measurement Cluster Callbacks */ +// @{ + +/** @brief Temperature Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTempMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Temperature Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTempMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Temperature Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTempMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTempMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Temperature Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTempMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Temperature Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTempMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Temperature Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTempMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTempMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Temperature Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTempMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Temperature Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTempMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTempMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Temperature Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTempMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Temperature Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTempMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Temperature Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTempMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Temperature Measurement Cluster Callbacks */ + +/** @name Pressure Measurement Cluster Callbacks */ +// @{ + +/** @brief Pressure Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPressureMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Pressure Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPressureMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Pressure Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPressureMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPressureMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pressure Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPressureMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Pressure Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPressureMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Pressure Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPressureMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPressureMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Pressure Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPressureMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Pressure Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPressureMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPressureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pressure Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPressureMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Pressure Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPressureMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Pressure Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPressureMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Pressure Measurement Cluster Callbacks */ + +/** @name Flow Measurement Cluster Callbacks */ +// @{ + +/** @brief Flow Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFlowMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Flow Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFlowMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Flow Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFlowMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFlowMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Flow Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFlowMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Flow Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFlowMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Flow Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFlowMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFlowMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Flow Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFlowMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Flow Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFlowMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFlowMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Flow Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFlowMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Flow Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFlowMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Flow Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFlowMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Flow Measurement Cluster Callbacks */ + +/** @name Relative Humidity Measurement Cluster Callbacks */ +// @{ + +/** @brief Relative Humidity Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Relative Humidity Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Relative Humidity Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Relative Humidity Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Relative Humidity Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRelativeHumidityMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Relative Humidity Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Relative Humidity Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Relative Humidity Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Relative Humidity Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Relative Humidity Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRelativeHumidityMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Relative Humidity Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Relative Humidity Measurement Cluster Callbacks */ + +/** @name Occupancy Sensing Cluster Callbacks */ +// @{ + +/** @brief Occupancy Sensing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOccupancySensingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Occupancy Sensing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOccupancySensingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Occupancy Sensing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOccupancySensingClusterClientInitCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOccupancySensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Occupancy Sensing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOccupancySensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Occupancy Sensing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOccupancySensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Occupancy Sensing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOccupancySensingClusterClientTickCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOccupancySensingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Occupancy Sensing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOccupancySensingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Occupancy Sensing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOccupancySensingClusterServerInitCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOccupancySensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Occupancy Sensing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOccupancySensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Occupancy Sensing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOccupancySensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Occupancy Sensing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOccupancySensingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Occupancy Sensing Cluster Callbacks */ + +/** @name Carbon Monoxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Carbon Monoxide Concentration Measurement Cluster Callbacks */ + +/** @name Carbon Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Carbon Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Ethylene Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ethylene Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ethylene Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ethylene Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ethylene Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ethylene Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ethylene Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ethylene Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ethylene Concentration Measurement Cluster Callbacks */ + +/** @name Ethylene Oxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ethylene Oxide Concentration Measurement Cluster Callbacks */ + +/** @name Hydrogen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Hydrogen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Hydrogen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Hydrogen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Hydrogen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Hydrogen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Hydrogen Concentration Measurement Cluster Callbacks */ + +/** @name Hydrogen Sulphide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Hydrogen Sulphide Concentration Measurement Cluster Callbacks */ + +/** @name Nitric Oxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Nitric Oxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Nitric Oxide Concentration Measurement Cluster Callbacks */ + +/** @name Nitrogen Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Nitrogen Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Oxygen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Oxygen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Oxygen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Oxygen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Oxygen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Oxygen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Oxygen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Oxygen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Oxygen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Oxygen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Oxygen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Oxygen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Oxygen Concentration Measurement Cluster Callbacks */ + +/** @name Ozone Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ozone Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ozone Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ozone Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ozone Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ozone Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOzoneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ozone Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ozone Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Ozone Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ozone Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Ozone Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOzoneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Ozone Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ozone Concentration Measurement Cluster Callbacks */ + +/** @name Sulfur Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sulfur Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Dissolved Oxygen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Dissolved Oxygen Concentration Measurement Cluster Callbacks */ + +/** @name Bromate Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromate Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromate Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromate Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromate Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromate Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromate Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromate Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromate Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromate Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromate Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromate Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromate Concentration Measurement Cluster Callbacks */ + +/** @name Chloramines Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chloramines Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloramines Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chloramines Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chloramines Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chloramines Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chloramines Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloramines Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chloramines Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chloramines Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chloramines Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chloramines Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chloramines Concentration Measurement Cluster Callbacks */ + +/** @name Chlorine Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chlorine Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorine Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorine Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chlorine Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chlorine Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorineConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chlorine Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorine Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorine Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chlorine Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chlorine Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorineConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chlorine Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chlorine Concentration Measurement Cluster Callbacks */ + +/** @name Fecal coliform and E. Coli Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fecal coliform and E. Coli Concentration Measurement Cluster Callbacks */ + +/** @name Fluoride Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Fluoride Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fluoride Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fluoride Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fluoride Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fluoride Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFluorideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fluoride Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fluoride Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Fluoride Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fluoride Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Fluoride Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFluorideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Fluoride Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fluoride Concentration Measurement Cluster Callbacks */ + +/** @name Haloacetic Acids Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Haloacetic Acids Concentration Measurement Cluster Callbacks */ + +/** @name Total Trihalomethanes Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Total Trihalomethanes Concentration Measurement Cluster Callbacks */ + +/** @name Total Coliform Bacteria Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Total Coliform Bacteria Concentration Measurement Cluster Callbacks */ + +/** @name Turbidity Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Turbidity Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Turbidity Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Turbidity Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Turbidity Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Turbidity Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Turbidity Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Turbidity Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Turbidity Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Turbidity Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Turbidity Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Turbidity Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Turbidity Concentration Measurement Cluster Callbacks */ + +/** @name Copper Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Copper Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Copper Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Copper Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Copper Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Copper Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCopperConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Copper Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Copper Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Copper Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Copper Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Copper Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCopperConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Copper Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Copper Concentration Measurement Cluster Callbacks */ + +/** @name Lead Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Lead Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Lead Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Lead Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Lead Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Lead Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLeadConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Lead Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Lead Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Lead Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Lead Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Lead Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLeadConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Lead Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Lead Concentration Measurement Cluster Callbacks */ + +/** @name Manganese Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Manganese Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Manganese Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Manganese Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Manganese Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Manganese Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfManganeseConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Manganese Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Manganese Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Manganese Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Manganese Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Manganese Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfManganeseConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Manganese Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Manganese Concentration Measurement Cluster Callbacks */ + +/** @name Sulfate Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sulfate Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfate Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfate Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfate Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sulfate Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sulfate Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfate Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfate Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfate Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sulfate Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sulfate Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sulfate Concentration Measurement Cluster Callbacks */ + +/** @name Bromodichloromethane Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromodichloromethane Concentration Measurement Cluster Callbacks */ + +/** @name Bromoform Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromoform Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromoform Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromoform Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromoform Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromoform Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromoformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromoform Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromoform Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Bromoform Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromoform Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Bromoform Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromoformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Bromoform Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromoform Concentration Measurement Cluster Callbacks */ + +/** @name Chlorodibromomethane Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chlorodibromomethane Concentration Measurement Cluster Callbacks */ + +/** @name Chloroform Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chloroform Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloroform Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chloroform Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chloroform Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chloroform Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloroformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chloroform Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloroform Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chloroform Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chloroform Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chloroform Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloroformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chloroform Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chloroform Concentration Measurement Cluster Callbacks */ + +/** @name Sodium Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sodium Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sodium Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sodium Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sodium Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sodium Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSodiumConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sodium Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sodium Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sodium Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sodium Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sodium Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSodiumConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sodium Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sodium Concentration Measurement Cluster Callbacks */ + +/** @name IAS Zone Cluster Callbacks */ +// @{ + +/** @brief IAS Zone Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasZoneClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS Zone Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasZoneClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS Zone Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasZoneClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasZoneClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasZoneClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS Zone Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasZoneClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS Zone Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasZoneClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Initiate Normal Operation Mode + * + * + * + */ +bool emberAfIasZoneClusterInitiateNormalOperationModeCallback(void); +/** @brief IAS Zone Cluster Initiate Normal Operation Mode Response + * + * + * + */ +bool emberAfIasZoneClusterInitiateNormalOperationModeResponseCallback(void); +/** @brief IAS Zone Cluster Initiate Test Mode + * + * + * + * @param testModeDuration Ver.: always + * @param currentZoneSensitivityLevel Ver.: always + */ +bool emberAfIasZoneClusterInitiateTestModeCallback(uint8_t testModeDuration, + uint8_t currentZoneSensitivityLevel); +/** @brief IAS Zone Cluster Initiate Test Mode Response + * + * + * + */ +bool emberAfIasZoneClusterInitiateTestModeResponseCallback(void); +/** @brief IAS Zone Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasZoneClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS Zone Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasZoneClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS Zone Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasZoneClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS Zone Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS Zone Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasZoneClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Zone Enroll Request + * + * + * + * @param zoneType Ver.: always + * @param manufacturerCode Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollRequestCallback(uint16_t zoneType, + uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Zone Enroll Response + * + * + * + * @param enrollResponseCode Ver.: always + * @param zoneId Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, + uint8_t zoneId); +/** @brief IAS Zone Cluster Zone Status Change Notification + * + * + * + * @param zoneStatus Ver.: always + * @param extendedStatus Ver.: always + * @param zoneId Ver.: since ha-1.2-05-3520-29 + * @param delay Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasZoneClusterZoneStatusChangeNotificationCallback(uint16_t zoneStatus, + uint8_t extendedStatus, + uint8_t zoneId, + uint16_t delay); + +/** @} END IAS Zone Cluster Callbacks */ + +/** @name IAS ACE Cluster Callbacks */ +// @{ + +/** @brief IAS ACE Cluster Arm + * + * + * + * @param armMode Ver.: always + * @param armDisarmCode Ver.: since ha-1.2-05-3520-29 + * @param zoneId Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasAceClusterArmCallback(uint8_t armMode, + uint8_t* armDisarmCode, + uint8_t zoneId); +/** @brief IAS ACE Cluster Arm Response + * + * + * + * @param armNotification Ver.: always + */ +bool emberAfIasAceClusterArmResponseCallback(uint8_t armNotification); +/** @brief IAS ACE Cluster Bypass + * + * + * + * @param numberOfZones Ver.: always + * @param zoneIds Ver.: always + * @param armDisarmCode Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterBypassCallback(uint8_t numberOfZones, + uint8_t* zoneIds, + uint8_t* armDisarmCode); +/** @brief IAS ACE Cluster Bypass Response + * + * + * + * @param numberOfZones Ver.: always + * @param bypassResult Ver.: always + */ +bool emberAfIasAceClusterBypassResponseCallback(uint8_t numberOfZones, + uint8_t* bypassResult); +/** @brief IAS ACE Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasAceClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS ACE Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasAceClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS ACE Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasAceClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasAceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS ACE Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasAceClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS ACE Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasAceClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS ACE Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasAceClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Emergency + * + * + * + */ +bool emberAfIasAceClusterEmergencyCallback(void); +/** @brief IAS ACE Cluster Fire + * + * + * + */ +bool emberAfIasAceClusterFireCallback(void); +/** @brief IAS ACE Cluster Get Bypassed Zone List + * + * + * + */ +bool emberAfIasAceClusterGetBypassedZoneListCallback(void); +/** @brief IAS ACE Cluster Get Panel Status + * + * + * + */ +bool emberAfIasAceClusterGetPanelStatusCallback(void); +/** @brief IAS ACE Cluster Get Panel Status Response + * + * + * + * @param panelStatus Ver.: always + * @param secondsRemaining Ver.: always + * @param audibleNotification Ver.: always + * @param alarmStatus Ver.: always + */ +bool emberAfIasAceClusterGetPanelStatusResponseCallback(uint8_t panelStatus, + uint8_t secondsRemaining, + uint8_t audibleNotification, + uint8_t alarmStatus); +/** @brief IAS ACE Cluster Get Zone Id Map + * + * + * + */ +bool emberAfIasAceClusterGetZoneIdMapCallback(void); +/** @brief IAS ACE Cluster Get Zone Id Map Response + * + * + * + * @param section0 Ver.: always + * @param section1 Ver.: always + * @param section2 Ver.: always + * @param section3 Ver.: always + * @param section4 Ver.: always + * @param section5 Ver.: always + * @param section6 Ver.: always + * @param section7 Ver.: always + * @param section8 Ver.: always + * @param section9 Ver.: always + * @param section10 Ver.: always + * @param section11 Ver.: always + * @param section12 Ver.: always + * @param section13 Ver.: always + * @param section14 Ver.: always + * @param section15 Ver.: always + */ +bool emberAfIasAceClusterGetZoneIdMapResponseCallback(uint16_t section0, + uint16_t section1, + uint16_t section2, + uint16_t section3, + uint16_t section4, + uint16_t section5, + uint16_t section6, + uint16_t section7, + uint16_t section8, + uint16_t section9, + uint16_t section10, + uint16_t section11, + uint16_t section12, + uint16_t section13, + uint16_t section14, + uint16_t section15); +/** @brief IAS ACE Cluster Get Zone Information + * + * + * + * @param zoneId Ver.: always + */ +bool emberAfIasAceClusterGetZoneInformationCallback(uint8_t zoneId); +/** @brief IAS ACE Cluster Get Zone Information Response + * + * + * + * @param zoneId Ver.: always + * @param zoneType Ver.: always + * @param ieeeAddress Ver.: always + * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterGetZoneInformationResponseCallback(uint8_t zoneId, + uint16_t zoneType, + uint8_t* ieeeAddress, + uint8_t* zoneLabel); +/** @brief IAS ACE Cluster Get Zone Status + * + * + * + * @param startingZoneId Ver.: always + * @param maxNumberOfZoneIds Ver.: always + * @param zoneStatusMaskFlag Ver.: always + * @param zoneStatusMask Ver.: always + */ +bool emberAfIasAceClusterGetZoneStatusCallback(uint8_t startingZoneId, + uint8_t maxNumberOfZoneIds, + uint8_t zoneStatusMaskFlag, + uint16_t zoneStatusMask); +/** @brief IAS ACE Cluster Get Zone Status Response + * + * + * + * @param zoneStatusComplete Ver.: always + * @param numberOfZones Ver.: always + * @param zoneStatusResult Ver.: always + */ +bool emberAfIasAceClusterGetZoneStatusResponseCallback(uint8_t zoneStatusComplete, + uint8_t numberOfZones, + uint8_t* zoneStatusResult); +/** @brief IAS ACE Cluster Panel Status Changed + * + * + * + * @param panelStatus Ver.: always + * @param secondsRemaining Ver.: always + * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 + * @param alarmStatus Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterPanelStatusChangedCallback(uint8_t panelStatus, + uint8_t secondsRemaining, + uint8_t audibleNotification, + uint8_t alarmStatus); +/** @brief IAS ACE Cluster Panic + * + * + * + */ +bool emberAfIasAceClusterPanicCallback(void); +/** @brief IAS ACE Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasAceClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS ACE Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasAceClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS ACE Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasAceClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasAceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS ACE Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasAceClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS ACE Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasAceClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS ACE Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasAceClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Set Bypassed Zone List + * + * + * + * @param numberOfZones Ver.: always + * @param zoneIds Ver.: always + */ +bool emberAfIasAceClusterSetBypassedZoneListCallback(uint8_t numberOfZones, + uint8_t* zoneIds); +/** @brief IAS ACE Cluster Zone Status Changed + * + * + * + * @param zoneId Ver.: always + * @param zoneStatus Ver.: always + * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 + * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterZoneStatusChangedCallback(uint8_t zoneId, + uint16_t zoneStatus, + uint8_t audibleNotification, + uint8_t* zoneLabel); + +/** @} END IAS ACE Cluster Callbacks */ + +/** @name IAS WD Cluster Callbacks */ +// @{ + +/** @brief IAS WD Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasWdClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS WD Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasWdClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS WD Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasWdClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasWdClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS WD Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasWdClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS WD Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasWdClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS WD Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasWdClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasWdClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief IAS WD Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasWdClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief IAS WD Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasWdClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasWdClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS WD Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasWdClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief IAS WD Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasWdClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief IAS WD Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasWdClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Squawk + * + * + * + * @param squawkInfo Ver.: always + */ +bool emberAfIasWdClusterSquawkCallback(uint8_t squawkInfo); +/** @brief IAS WD Cluster Start Warning + * + * + * + * @param warningInfo Ver.: always + * @param warningDuration Ver.: always + * @param strobeDutyCycle Ver.: since ha-1.2-05-3520-29 + * @param strobeLevel Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasWdClusterStartWarningCallback(uint8_t warningInfo, + uint16_t warningDuration, + uint8_t strobeDutyCycle, + uint8_t strobeLevel); + +/** @} END IAS WD Cluster Callbacks */ + +/** @name Generic Tunnel Cluster Callbacks */ +// @{ + +/** @brief Generic Tunnel Cluster Advertise Protocol Address + * + * + * + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterAdvertiseProtocolAddressCallback(uint8_t* protocolAddress); +/** @brief Generic Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGenericTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Generic Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGenericTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Generic Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGenericTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGenericTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Generic Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGenericTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Generic Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGenericTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Generic Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGenericTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Match Protocol Address + * + * + * + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterMatchProtocolAddressCallback(uint8_t* protocolAddress); +/** @brief Generic Tunnel Cluster Match Protocol Address Response + * + * + * + * @param deviceIeeeAddress Ver.: always + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterMatchProtocolAddressResponseCallback(uint8_t* deviceIeeeAddress, + uint8_t* protocolAddress); +/** @brief Generic Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGenericTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Generic Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGenericTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Generic Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGenericTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGenericTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Generic Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGenericTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Generic Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGenericTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Generic Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGenericTunnelClusterServerTickCallback(uint8_t endpoint); + +/** @} END Generic Tunnel Cluster Callbacks */ + +/** @name BACnet Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief BACnet Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief BACnet Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief BACnet Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief BACnet Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief BACnet Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBacnetProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief BACnet Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief BACnet Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief BACnet Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief BACnet Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief BACnet Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBacnetProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief BACnet Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Transfer Npdu + * + * + * + * @param npdu Ver.: always + */ +bool emberAfBacnetProtocolTunnelClusterTransferNpduCallback(uint8_t* npdu); + +/** @} END BACnet Protocol Tunnel Cluster Callbacks */ + +/** @name 11073 Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief 11073 Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief 11073 Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief 11073 Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief 11073 Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief 11073 Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAf11073ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief 11073 Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Connect Request + * + * + * + * @param connectControl Ver.: always + * @param idleTimeout Ver.: always + * @param managerTarget Ver.: always + * @param managerEndpoint Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterConnectRequestCallback(uint8_t connectControl, + uint16_t idleTimeout, + uint8_t* managerTarget, + uint8_t managerEndpoint); +/** @brief 11073 Protocol Tunnel Cluster Connect Status Notification + * + * + * + * @param connectStatus Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterConnectStatusNotificationCallback(uint8_t connectStatus); +/** @brief 11073 Protocol Tunnel Cluster Disconnect Request + * + * + * + * @param managerIEEEAddress Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterDisconnectRequestCallback(uint8_t* managerIEEEAddress); +/** @brief 11073 Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief 11073 Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief 11073 Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief 11073 Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief 11073 Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAf11073ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief 11073 Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Transfer A P D U + * + * + * + * @param apdu Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterTransferAPDUCallback(uint8_t* apdu); + +/** @} END 11073 Protocol Tunnel Cluster Callbacks */ + +/** @name ISO 7816 Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief ISO 7816 Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIso7816ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Extract Smart Card + * + * + * + */ +bool emberAfIso7816ProtocolTunnelClusterExtractSmartCardCallback(void); +/** @brief ISO 7816 Protocol Tunnel Cluster Insert Smart Card + * + * + * + */ +bool emberAfIso7816ProtocolTunnelClusterInsertSmartCardCallback(void); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIso7816ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Transfer Apdu + * + * + * + * @param apdu Ver.: always + */ +bool emberAfIso7816ProtocolTunnelClusterTransferApduCallback(uint8_t* apdu); + +/** @} END ISO 7816 Protocol Tunnel Cluster Callbacks */ + +/** @name Price Cluster Callbacks */ +// @{ + +/** @brief Price Cluster Cancel Tariff + * + * + * + * @param providerId Ver.: always + * @param issuerTariffId Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterCancelTariffCallback(uint32_t providerId, + uint32_t issuerTariffId, + uint8_t tariffType); +/** @brief Price Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPriceClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Price Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPriceClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Price Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPriceClusterClientInitCallback(uint8_t endpoint); +/** @brief Price Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPriceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Price Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPriceClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Price Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPriceClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Price Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPriceClusterClientTickCallback(uint8_t endpoint); +/** @brief Price Cluster Cpp Event Response + * + * + * + * @param issuerEventId Ver.: always + * @param cppAuth Ver.: always + */ +bool emberAfPriceClusterCppEventResponseCallback(uint32_t issuerEventId, + uint8_t cppAuth); +/** @brief Price Cluster Get Billing Period + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetBillingPeriodCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Block Periods + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetBlockPeriodsCallback(uint32_t startTime, + uint8_t numberOfEvents, + uint8_t tariffType); +/** @brief Price Cluster Get Block Thresholds + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetBlockThresholdsCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Get C O2 Value + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetCO2ValueCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Calorific Value + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + */ +bool emberAfPriceClusterGetCalorificValueCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands); +/** @brief Price Cluster Get Consolidated Bill + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetConsolidatedBillCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Conversion Factor + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + */ +bool emberAfPriceClusterGetConversionFactorCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands); +/** @brief Price Cluster Get Credit Payment + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfRecords Ver.: always + */ +bool emberAfPriceClusterGetCreditPaymentCallback(uint32_t latestEndTime, + uint8_t numberOfRecords); +/** @brief Price Cluster Get Currency Conversion Command + * + * + * + */ +bool emberAfPriceClusterGetCurrencyConversionCommandCallback(void); +/** @brief Price Cluster Get Current Price + * + * + * + * @param commandOptions Ver.: always + */ +bool emberAfPriceClusterGetCurrentPriceCallback(uint8_t commandOptions); +/** @brief Price Cluster Get Price Matrix + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetPriceMatrixCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Get Scheduled Prices + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + */ +bool emberAfPriceClusterGetScheduledPricesCallback(uint32_t startTime, + uint8_t numberOfEvents); +/** @brief Price Cluster Get Tariff Cancellation + * + * + * + */ +bool emberAfPriceClusterGetTariffCancellationCallback(void); +/** @brief Price Cluster Get Tariff Information + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetTariffInformationCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Tier Labels + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetTierLabelsCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Price Acknowledgement + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param priceAckTime Ver.: always + * @param control Ver.: always + */ +bool emberAfPriceClusterPriceAcknowledgementCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t priceAckTime, + uint8_t control); +/** @brief Price Cluster Publish Billing Period + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param billingPeriodStartTime Ver.: always + * @param billingPeriodDuration Ver.: always + * @param billingPeriodDurationType Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterPublishBillingPeriodCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t billingPeriodStartTime, + uint32_t billingPeriodDuration, + uint8_t billingPeriodDurationType, + uint8_t tariffType); +/** @brief Price Cluster Publish Block Period + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param blockPeriodStartTime Ver.: always + * @param blockPeriodDuration Ver.: always + * @param blockPeriodControl Ver.: always + * @param blockPeriodDurationType Ver.: since se-1.2a-07-5356-19 + * @param tariffType Ver.: since se-1.2a-07-5356-19 + * @param tariffResolutionPeriod Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfPriceClusterPublishBlockPeriodCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t blockPeriodStartTime, + uint32_t blockPeriodDuration, + uint8_t blockPeriodControl, + uint8_t blockPeriodDurationType, + uint8_t tariffType, + uint8_t tariffResolutionPeriod); +/** @brief Price Cluster Publish Block Thresholds + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param subPayloadControl Ver.: always + * @param payload Ver.: always + */ +bool emberAfPriceClusterPublishBlockThresholdsCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t startTime, + uint32_t issuerTariffId, + uint8_t commandIndex, + uint8_t numberOfCommands, + uint8_t subPayloadControl, + uint8_t* payload); +/** @brief Price Cluster Publish C O2 Value + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param tariffType Ver.: always + * @param cO2Value Ver.: always + * @param cO2ValueUnit Ver.: always + * @param cO2ValueTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishCO2ValueCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t startTime, + uint8_t tariffType, + uint32_t cO2Value, + uint8_t cO2ValueUnit, + uint8_t cO2ValueTrailingDigit); +/** @brief Price Cluster Publish Calorific Value + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param calorificValue Ver.: always + * @param calorificValueUnit Ver.: always + * @param calorificValueTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishCalorificValueCallback(uint32_t issuerEventId, + uint32_t startTime, + uint32_t calorificValue, + uint8_t calorificValueUnit, + uint8_t calorificValueTrailingDigit); +/** @brief Price Cluster Publish Consolidated Bill + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param billingPeriodStartTime Ver.: always + * @param billingPeriodDuration Ver.: always + * @param billingPeriodDurationType Ver.: always + * @param tariffType Ver.: always + * @param consolidatedBill Ver.: always + * @param currency Ver.: always + * @param billTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishConsolidatedBillCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t billingPeriodStartTime, + uint32_t billingPeriodDuration, + uint8_t billingPeriodDurationType, + uint8_t tariffType, + uint32_t consolidatedBill, + uint16_t currency, + uint8_t billTrailingDigit); +/** @brief Price Cluster Publish Conversion Factor + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param conversionFactor Ver.: always + * @param conversionFactorTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishConversionFactorCallback(uint32_t issuerEventId, + uint32_t startTime, + uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit); +/** @brief Price Cluster Publish Cpp Event + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param tariffType Ver.: always + * @param cppPriceTier Ver.: always + * @param cppAuth Ver.: always + */ +bool emberAfPriceClusterPublishCppEventCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t startTime, + uint16_t durationInMinutes, + uint8_t tariffType, + uint8_t cppPriceTier, + uint8_t cppAuth); +/** @brief Price Cluster Publish Credit Payment + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param creditPaymentDueDate Ver.: always + * @param creditPaymentOverDueAmount Ver.: always + * @param creditPaymentStatus Ver.: always + * @param creditPayment Ver.: always + * @param creditPaymentDate Ver.: always + * @param creditPaymentRef Ver.: always + */ +bool emberAfPriceClusterPublishCreditPaymentCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t creditPaymentDueDate, + uint32_t creditPaymentOverDueAmount, + uint8_t creditPaymentStatus, + uint32_t creditPayment, + uint32_t creditPaymentDate, + uint8_t* creditPaymentRef); +/** @brief Price Cluster Publish Currency Conversion + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param oldCurrency Ver.: always + * @param newCurrency Ver.: always + * @param conversionFactor Ver.: always + * @param conversionFactorTrailingDigit Ver.: always + * @param currencyChangeControlFlags Ver.: always + */ +bool emberAfPriceClusterPublishCurrencyConversionCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t startTime, + uint16_t oldCurrency, + uint16_t newCurrency, + uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit, + uint32_t currencyChangeControlFlags); +/** @brief Price Cluster Publish Price + * + * + * + * @param providerId Ver.: always + * @param rateLabel Ver.: always + * @param issuerEventId Ver.: always + * @param currentTime Ver.: always + * @param unitOfMeasure Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigitAndPriceTier Ver.: always + * @param numberOfPriceTiersAndRegisterTier Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param price Ver.: always + * @param priceRatio Ver.: always + * @param generationPrice Ver.: always + * @param generationPriceRatio Ver.: always + * @param alternateCostDelivered Ver.: since se-1.0-07-5356-15 + * @param alternateCostUnit Ver.: since se-1.0-07-5356-15 + * @param alternateCostTrailingDigit Ver.: since se-1.0-07-5356-15 + * @param numberOfBlockThresholds Ver.: since se-1.1-07-5356-16 + * @param priceControl Ver.: since se-1.1-07-5356-16 + * @param numberOfGenerationTiers Ver.: since se-1.2a-07-5356-19 + * @param generationTier Ver.: since se-1.2a-07-5356-19 + * @param extendedNumberOfPriceTiers Ver.: since se-1.2a-07-5356-19 + * @param extendedPriceTier Ver.: since se-1.2a-07-5356-19 + * @param extendedRegisterTier Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfPriceClusterPublishPriceCallback(uint32_t providerId, + uint8_t* rateLabel, + uint32_t issuerEventId, + uint32_t currentTime, + uint8_t unitOfMeasure, + uint16_t currency, + uint8_t priceTrailingDigitAndPriceTier, + uint8_t numberOfPriceTiersAndRegisterTier, + uint32_t startTime, + uint16_t durationInMinutes, + uint32_t price, + uint8_t priceRatio, + uint32_t generationPrice, + uint8_t generationPriceRatio, + uint32_t alternateCostDelivered, + uint8_t alternateCostUnit, + uint8_t alternateCostTrailingDigit, + uint8_t numberOfBlockThresholds, + uint8_t priceControl, + uint8_t numberOfGenerationTiers, + uint8_t generationTier, + uint8_t extendedNumberOfPriceTiers, + uint8_t extendedPriceTier, + uint8_t extendedRegisterTier); +/** @brief Price Cluster Publish Price Matrix + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param subPayloadControl Ver.: always + * @param payload Ver.: always + */ +bool emberAfPriceClusterPublishPriceMatrixCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t startTime, + uint32_t issuerTariffId, + uint8_t commandIndex, + uint8_t numberOfCommands, + uint8_t subPayloadControl, + uint8_t* payload); +/** @brief Price Cluster Publish Tariff Information + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerTariffId Ver.: always + * @param startTime Ver.: always + * @param tariffTypeChargingScheme Ver.: always + * @param tariffLabel Ver.: always + * @param numberOfPriceTiersInUse Ver.: always + * @param numberOfBlockThresholdsInUse Ver.: always + * @param unitOfMeasure Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param standingCharge Ver.: always + * @param tierBlockMode Ver.: always + * @param blockThresholdMultiplier Ver.: always + * @param blockThresholdDivisor Ver.: always + */ +bool emberAfPriceClusterPublishTariffInformationCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerTariffId, + uint32_t startTime, + uint8_t tariffTypeChargingScheme, + uint8_t* tariffLabel, + uint8_t numberOfPriceTiersInUse, + uint8_t numberOfBlockThresholdsInUse, + uint8_t unitOfMeasure, + uint16_t currency, + uint8_t priceTrailingDigit, + uint32_t standingCharge, + uint8_t tierBlockMode, + uint32_t blockThresholdMultiplier, + uint32_t blockThresholdDivisor); +/** @brief Price Cluster Publish Tier Labels + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param numberOfLabels Ver.: always + * @param tierLabelsPayload Ver.: always + */ +bool emberAfPriceClusterPublishTierLabelsCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerTariffId, + uint8_t commandIndex, + uint8_t numberOfCommands, + uint8_t numberOfLabels, + uint8_t* tierLabelsPayload); +/** @brief Price Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPriceClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Price Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPriceClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Price Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPriceClusterServerInitCallback(uint8_t endpoint); +/** @brief Price Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPriceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Price Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPriceClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Price Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPriceClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Price Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPriceClusterServerTickCallback(uint8_t endpoint); + +/** @} END Price Cluster Callbacks */ + +/** @name Demand Response and Load Control Cluster Callbacks */ +// @{ + +/** @brief Demand Response and Load Control Cluster Cancel All Load Control Events + * + * + * + * @param cancelControl Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterCancelAllLoadControlEventsCallback(uint8_t cancelControl); +/** @brief Demand Response and Load Control Cluster Cancel Load Control Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param cancelControl Ver.: always + * @param effectiveTime Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterCancelLoadControlEventCallback(uint32_t issuerEventId, + uint16_t deviceClass, + uint8_t utilityEnrollmentGroup, + uint8_t cancelControl, + uint32_t effectiveTime); +/** @brief Demand Response and Load Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Demand Response and Load Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Demand Response and Load Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Demand Response and Load Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Demand Response and Load Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDemandResponseLoadControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Demand Response and Load Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Get Scheduled Events + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param issuerEventId Ver.: since se-1.2b-15-0131-02 + */ +bool emberAfDemandResponseLoadControlClusterGetScheduledEventsCallback(uint32_t startTime, + uint8_t numberOfEvents, + uint32_t issuerEventId); +/** @brief Demand Response and Load Control Cluster Load Control Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param criticalityLevel Ver.: always + * @param coolingTemperatureOffset Ver.: always + * @param heatingTemperatureOffset Ver.: always + * @param coolingTemperatureSetPoint Ver.: always + * @param heatingTemperatureSetPoint Ver.: always + * @param averageLoadAdjustmentPercentage Ver.: always + * @param dutyCycle Ver.: always + * @param eventControl Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterLoadControlEventCallback(uint32_t issuerEventId, + uint16_t deviceClass, + uint8_t utilityEnrollmentGroup, + uint32_t startTime, + uint16_t durationInMinutes, + uint8_t criticalityLevel, + uint8_t coolingTemperatureOffset, + uint8_t heatingTemperatureOffset, + int16_t coolingTemperatureSetPoint, + int16_t heatingTemperatureSetPoint, + int8_t averageLoadAdjustmentPercentage, + uint8_t dutyCycle, + uint8_t eventControl); +/** @brief Demand Response and Load Control Cluster Report Event Status + * + * + * + * @param issuerEventId Ver.: always + * @param eventStatus Ver.: always + * @param eventStatusTime Ver.: always + * @param criticalityLevelApplied Ver.: always + * @param coolingTemperatureSetPointApplied Ver.: always + * @param heatingTemperatureSetPointApplied Ver.: always + * @param averageLoadAdjustmentPercentageApplied Ver.: always + * @param dutyCycleApplied Ver.: always + * @param eventControl Ver.: always + * @param signatureType Ver.: always + * @param signature Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterReportEventStatusCallback(uint32_t issuerEventId, + uint8_t eventStatus, + uint32_t eventStatusTime, + uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, + uint8_t eventControl, + uint8_t signatureType, + uint8_t* signature); +/** @brief Demand Response and Load Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Demand Response and Load Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Demand Response and Load Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Demand Response and Load Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Demand Response and Load Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDemandResponseLoadControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Demand Response and Load Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Demand Response and Load Control Cluster Callbacks */ + +/** @name Simple Metering Cluster Callbacks */ +// @{ + +/** @brief Simple Metering Cluster Change Supply + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param requestDateTime Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedSupplyStatus Ver.: always + * @param supplyControlBits Ver.: always + */ +bool emberAfSimpleMeteringClusterChangeSupplyCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t requestDateTime, + uint32_t implementationDateTime, + uint8_t proposedSupplyStatus, + uint8_t supplyControlBits); +/** @brief Simple Metering Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSimpleMeteringClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Simple Metering Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSimpleMeteringClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Simple Metering Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSimpleMeteringClusterClientInitCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSimpleMeteringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Simple Metering Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSimpleMeteringClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Simple Metering Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSimpleMeteringClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Simple Metering Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSimpleMeteringClusterClientTickCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Configure Mirror + * + * + * + * @param issuerEventId Ver.: always + * @param reportingInterval Ver.: always + * @param mirrorNotificationReporting Ver.: always + * @param notificationScheme Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureMirrorCallback(uint32_t issuerEventId, + uint32_t reportingInterval, + uint8_t mirrorNotificationReporting, + uint8_t notificationScheme); +/** @brief Simple Metering Cluster Configure Notification Flags + * + * + * + * @param issuerEventId Ver.: always + * @param notificationScheme Ver.: always + * @param notificationFlagAttributeId Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param numberOfCommands Ver.: always + * @param commandIds Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureNotificationFlagsCallback(uint32_t issuerEventId, + uint8_t notificationScheme, + uint16_t notificationFlagAttributeId, + uint16_t clusterId, + uint16_t manufacturerCode, + uint8_t numberOfCommands, + uint8_t* commandIds); +/** @brief Simple Metering Cluster Configure Notification Scheme + * + * + * + * @param issuerEventId Ver.: always + * @param notificationScheme Ver.: always + * @param notificationFlagOrder Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureNotificationSchemeCallback(uint32_t issuerEventId, + uint8_t notificationScheme, + uint32_t notificationFlagOrder); +/** @brief Simple Metering Cluster Get Notified Message + * + * + * + * @param notificationScheme Ver.: always + * @param notificationFlagAttributeId Ver.: always + * @param notificationFlagsN Ver.: always + */ +bool emberAfSimpleMeteringClusterGetNotifiedMessageCallback(uint8_t notificationScheme, + uint16_t notificationFlagAttributeId, + uint32_t notificationFlagsN); +/** @brief Simple Metering Cluster Get Profile + * + * + * + * @param intervalChannel Ver.: always + * @param endTime Ver.: always + * @param numberOfPeriods Ver.: always + */ +bool emberAfSimpleMeteringClusterGetProfileCallback(uint8_t intervalChannel, + uint32_t endTime, + uint8_t numberOfPeriods); +/** @brief Simple Metering Cluster Get Profile Response + * + * + * + * @param endTime Ver.: always + * @param status Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param numberOfPeriodsDelivered Ver.: always + * @param intervals Ver.: always + */ +bool emberAfSimpleMeteringClusterGetProfileResponseCallback(uint32_t endTime, + uint8_t status, + uint8_t profileIntervalPeriod, + uint8_t numberOfPeriodsDelivered, + uint8_t* intervals); +/** @brief Simple Metering Cluster Get Sampled Data + * + * + * + * @param sampleId Ver.: always + * @param earliestSampleTime Ver.: always + * @param sampleType Ver.: always + * @param numberOfSamples Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSampledDataCallback(uint16_t sampleId, + uint32_t earliestSampleTime, + uint8_t sampleType, + uint16_t numberOfSamples); +/** @brief Simple Metering Cluster Get Sampled Data Response + * + * + * + * @param sampleId Ver.: always + * @param sampleStartTime Ver.: always + * @param sampleType Ver.: always + * @param sampleRequestInterval Ver.: always + * @param numberOfSamples Ver.: always + * @param samples Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSampledDataResponseCallback(uint16_t sampleId, + uint32_t sampleStartTime, + uint8_t sampleType, + uint16_t sampleRequestInterval, + uint16_t numberOfSamples, + uint8_t* samples); +/** @brief Simple Metering Cluster Get Snapshot + * + * + * + * @param earliestStartTime Ver.: always + * @param latestEndTime Ver.: always + * @param snapshotOffset Ver.: always + * @param snapshotCause Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSnapshotCallback(uint32_t earliestStartTime, + uint32_t latestEndTime, + uint8_t snapshotOffset, + uint32_t snapshotCause); +/** @brief Simple Metering Cluster Local Change Supply + * + * + * + * @param proposedSupplyStatus Ver.: always + */ +bool emberAfSimpleMeteringClusterLocalChangeSupplyCallback(uint8_t proposedSupplyStatus); +/** @brief Simple Metering Cluster Mirror Removed + * + * + * + * @param endpointId Ver.: always + */ +bool emberAfSimpleMeteringClusterMirrorRemovedCallback(uint16_t endpointId); +/** @brief Simple Metering Cluster Mirror Report Attribute Response + * + * + * + * @param notificationScheme Ver.: always + * @param notificationFlags Ver.: always + */ +bool emberAfSimpleMeteringClusterMirrorReportAttributeResponseCallback(uint8_t notificationScheme, + uint8_t* notificationFlags); +/** @brief Simple Metering Cluster Publish Snapshot + * + * + * + * @param snapshotId Ver.: always + * @param snapshotTime Ver.: always + * @param totalSnapshotsFound Ver.: always + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param snapshotCause Ver.: always + * @param snapshotPayloadType Ver.: always + * @param snapshotPayload Ver.: always + */ +bool emberAfSimpleMeteringClusterPublishSnapshotCallback(uint32_t snapshotId, + uint32_t snapshotTime, + uint8_t totalSnapshotsFound, + uint8_t commandIndex, + uint8_t totalCommands, + uint32_t snapshotCause, + uint8_t snapshotPayloadType, + uint8_t* snapshotPayload); +/** @brief Simple Metering Cluster Remove Mirror + * + * + * + */ +bool emberAfSimpleMeteringClusterRemoveMirrorCallback(void); +/** @brief Simple Metering Cluster Request Fast Poll Mode + * + * + * + * @param fastPollUpdatePeriod Ver.: always + * @param duration Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestFastPollModeCallback(uint8_t fastPollUpdatePeriod, + uint8_t duration); +/** @brief Simple Metering Cluster Request Fast Poll Mode Response + * + * + * + * @param appliedUpdatePeriod Ver.: always + * @param fastPollModeEndtime Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestFastPollModeResponseCallback(uint8_t appliedUpdatePeriod, + uint32_t fastPollModeEndtime); +/** @brief Simple Metering Cluster Request Mirror + * + * + * + */ +bool emberAfSimpleMeteringClusterRequestMirrorCallback(void); +/** @brief Simple Metering Cluster Request Mirror Response + * + * + * + * @param endpointId Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestMirrorResponseCallback(uint16_t endpointId); +/** @brief Simple Metering Cluster Reset Load Limit Counter + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + */ +bool emberAfSimpleMeteringClusterResetLoadLimitCounterCallback(uint32_t providerId, + uint32_t issuerEventId); +/** @brief Simple Metering Cluster Schedule Snapshot + * + * + * + * @param issuerEventId Ver.: always + * @param commandIndex Ver.: always + * @param commandCount Ver.: always + * @param snapshotSchedulePayload Ver.: always + */ +bool emberAfSimpleMeteringClusterScheduleSnapshotCallback(uint32_t issuerEventId, + uint8_t commandIndex, + uint8_t commandCount, + uint8_t* snapshotSchedulePayload); +/** @brief Simple Metering Cluster Schedule Snapshot Response + * + * + * + * @param issuerEventId Ver.: always + * @param snapshotResponsePayload Ver.: always + */ +bool emberAfSimpleMeteringClusterScheduleSnapshotResponseCallback(uint32_t issuerEventId, + uint8_t* snapshotResponsePayload); +/** @brief Simple Metering Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSimpleMeteringClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Simple Metering Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSimpleMeteringClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Simple Metering Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSimpleMeteringClusterServerInitCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSimpleMeteringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Simple Metering Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSimpleMeteringClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Simple Metering Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSimpleMeteringClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Simple Metering Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSimpleMeteringClusterServerTickCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Set Supply Status + * + * + * + * @param issuerEventId Ver.: always + * @param supplyTamperState Ver.: always + * @param supplyDepletionState Ver.: always + * @param supplyUncontrolledFlowState Ver.: always + * @param loadLimitSupplyState Ver.: always + */ +bool emberAfSimpleMeteringClusterSetSupplyStatusCallback(uint32_t issuerEventId, + uint8_t supplyTamperState, + uint8_t supplyDepletionState, + uint8_t supplyUncontrolledFlowState, + uint8_t loadLimitSupplyState); +/** @brief Simple Metering Cluster Set Uncontrolled Flow Threshold + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param uncontrolledFlowThreshold Ver.: always + * @param unitOfMeasure Ver.: always + * @param multiplier Ver.: always + * @param divisor Ver.: always + * @param stabilisationPeriod Ver.: always + * @param measurementPeriod Ver.: always + */ +bool emberAfSimpleMeteringClusterSetUncontrolledFlowThresholdCallback(uint32_t providerId, + uint32_t issuerEventId, + uint16_t uncontrolledFlowThreshold, + uint8_t unitOfMeasure, + uint16_t multiplier, + uint16_t divisor, + uint8_t stabilisationPeriod, + uint16_t measurementPeriod); +/** @brief Simple Metering Cluster Start Sampling + * + * + * + * @param issuerEventId Ver.: always + * @param startSamplingTime Ver.: always + * @param sampleType Ver.: always + * @param sampleRequestInterval Ver.: always + * @param maxNumberOfSamples Ver.: always + */ +bool emberAfSimpleMeteringClusterStartSamplingCallback(uint32_t issuerEventId, + uint32_t startSamplingTime, + uint8_t sampleType, + uint16_t sampleRequestInterval, + uint16_t maxNumberOfSamples); +/** @brief Simple Metering Cluster Start Sampling Response + * + * + * + * @param sampleId Ver.: always + */ +bool emberAfSimpleMeteringClusterStartSamplingResponseCallback(uint16_t sampleId); +/** @brief Simple Metering Cluster Supply Status Response + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param supplyStatus Ver.: always + */ +bool emberAfSimpleMeteringClusterSupplyStatusResponseCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t implementationDateTime, + uint8_t supplyStatus); +/** @brief Simple Metering Cluster Take Snapshot + * + * + * + * @param snapshotCause Ver.: always + */ +bool emberAfSimpleMeteringClusterTakeSnapshotCallback(uint32_t snapshotCause); +/** @brief Simple Metering Cluster Take Snapshot Response + * + * + * + * @param snapshotId Ver.: always + * @param snapshotConfirmation Ver.: always + */ +bool emberAfSimpleMeteringClusterTakeSnapshotResponseCallback(uint32_t snapshotId, + uint8_t snapshotConfirmation); + +/** @} END Simple Metering Cluster Callbacks */ + +/** @name Messaging Cluster Callbacks */ +// @{ + +/** @brief Messaging Cluster Cancel All Messages + * + * + * + * @param implementationDateTime Ver.: always + */ +bool emberAfMessagingClusterCancelAllMessagesCallback(uint32_t implementationDateTime); +/** @brief Messaging Cluster Cancel Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + */ +bool emberAfMessagingClusterCancelMessageCallback(uint32_t messageId, + uint8_t messageControl); +/** @brief Messaging Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMessagingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Messaging Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMessagingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Messaging Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMessagingClusterClientInitCallback(uint8_t endpoint); +/** @brief Messaging Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMessagingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Messaging Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMessagingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Messaging Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMessagingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Messaging Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMessagingClusterClientTickCallback(uint8_t endpoint); +/** @brief Messaging Cluster Display Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param message Ver.: always + * @param optionalExtendedMessageControl Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfMessagingClusterDisplayMessageCallback(uint32_t messageId, + uint8_t messageControl, + uint32_t startTime, + uint16_t durationInMinutes, + uint8_t* message, + uint8_t optionalExtendedMessageControl); +/** @brief Messaging Cluster Display Protected Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param message Ver.: always + * @param optionalExtendedMessageControl Ver.: always + */ +bool emberAfMessagingClusterDisplayProtectedMessageCallback(uint32_t messageId, + uint8_t messageControl, + uint32_t startTime, + uint16_t durationInMinutes, + uint8_t* message, + uint8_t optionalExtendedMessageControl); +/** @brief Messaging Cluster Get Last Message + * + * + * + */ +bool emberAfMessagingClusterGetLastMessageCallback(void); +/** @brief Messaging Cluster Get Message Cancellation + * + * + * + * @param earliestImplementationTime Ver.: always + */ +bool emberAfMessagingClusterGetMessageCancellationCallback(uint32_t earliestImplementationTime); +/** @brief Messaging Cluster Message Confirmation + * + * + * + * @param messageId Ver.: always + * @param confirmationTime Ver.: always + * @param messageConfirmationControl Ver.: since se-1.2a-07-5356-19 + * @param messageResponse Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfMessagingClusterMessageConfirmationCallback(uint32_t messageId, + uint32_t confirmationTime, + uint8_t messageConfirmationControl, + uint8_t* messageResponse); +/** @brief Messaging Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMessagingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Messaging Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMessagingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Messaging Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMessagingClusterServerInitCallback(uint8_t endpoint); +/** @brief Messaging Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMessagingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Messaging Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMessagingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Messaging Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMessagingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Messaging Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMessagingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Messaging Cluster Callbacks */ + +/** @name Tunneling Cluster Callbacks */ +// @{ + +/** @brief Tunneling Cluster Ack Transfer Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param numberOfBytesLeft Ver.: always + */ +bool emberAfTunnelingClusterAckTransferDataClientToServerCallback(uint16_t tunnelId, + uint16_t numberOfBytesLeft); +/** @brief Tunneling Cluster Ack Transfer Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param numberOfBytesLeft Ver.: always + */ +bool emberAfTunnelingClusterAckTransferDataServerToClientCallback(uint16_t tunnelId, + uint16_t numberOfBytesLeft); +/** @brief Tunneling Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTunnelingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Tunneling Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTunnelingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Tunneling Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTunnelingClusterClientInitCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTunnelingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Tunneling Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTunnelingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Tunneling Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTunnelingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Tunneling Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTunnelingClusterClientTickCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Close Tunnel + * + * + * + * @param tunnelId Ver.: always + */ +bool emberAfTunnelingClusterCloseTunnelCallback(uint16_t tunnelId); +/** @brief Tunneling Cluster Get Supported Tunnel Protocols + * + * + * + * @param protocolOffset Ver.: always + */ +bool emberAfTunnelingClusterGetSupportedTunnelProtocolsCallback(uint8_t protocolOffset); +/** @brief Tunneling Cluster Ready Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param numberOfOctetsLeft Ver.: always + */ +bool emberAfTunnelingClusterReadyDataClientToServerCallback(uint16_t tunnelId, + uint16_t numberOfOctetsLeft); +/** @brief Tunneling Cluster Ready Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param numberOfOctetsLeft Ver.: always + */ +bool emberAfTunnelingClusterReadyDataServerToClientCallback(uint16_t tunnelId, + uint16_t numberOfOctetsLeft); +/** @brief Tunneling Cluster Request Tunnel + * + * + * + * @param protocolId Ver.: always + * @param manufacturerCode Ver.: always + * @param flowControlSupport Ver.: always + * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 + */ +bool emberAfTunnelingClusterRequestTunnelCallback(uint8_t protocolId, + uint16_t manufacturerCode, + uint8_t flowControlSupport, + uint16_t maximumIncomingTransferSize); +/** @brief Tunneling Cluster Request Tunnel Response + * + * + * + * @param tunnelId Ver.: always + * @param tunnelStatus Ver.: always + * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 + */ +bool emberAfTunnelingClusterRequestTunnelResponseCallback(uint16_t tunnelId, + uint8_t tunnelStatus, + uint16_t maximumIncomingTransferSize); +/** @brief Tunneling Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTunnelingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Tunneling Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTunnelingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Tunneling Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTunnelingClusterServerInitCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTunnelingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Tunneling Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTunnelingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Tunneling Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTunnelingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Tunneling Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTunnelingClusterServerTickCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Supported Tunnel Protocols Response + * + * + * + * @param protocolListComplete Ver.: always + * @param protocolCount Ver.: always + * @param protocolList Ver.: always + */ +bool emberAfTunnelingClusterSupportedTunnelProtocolsResponseCallback(uint8_t protocolListComplete, + uint8_t protocolCount, + uint8_t* protocolList); +/** @brief Tunneling Cluster Transfer Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param data Ver.: always + */ +bool emberAfTunnelingClusterTransferDataClientToServerCallback(uint16_t tunnelId, + uint8_t* data); +/** @brief Tunneling Cluster Transfer Data Error Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param transferDataStatus Ver.: always + */ +bool emberAfTunnelingClusterTransferDataErrorClientToServerCallback(uint16_t tunnelId, + uint8_t transferDataStatus); +/** @brief Tunneling Cluster Transfer Data Error Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param transferDataStatus Ver.: always + */ +bool emberAfTunnelingClusterTransferDataErrorServerToClientCallback(uint16_t tunnelId, + uint8_t transferDataStatus); +/** @brief Tunneling Cluster Transfer Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param data Ver.: always + */ +bool emberAfTunnelingClusterTransferDataServerToClientCallback(uint16_t tunnelId, + uint8_t* data); +/** @brief Tunneling Cluster Tunnel Closure Notification + * + * + * + * @param tunnelId Ver.: always + */ +bool emberAfTunnelingClusterTunnelClosureNotificationCallback(uint16_t tunnelId); + +/** @} END Tunneling Cluster Callbacks */ + +/** @name Prepayment Cluster Callbacks */ +// @{ + +/** @brief Prepayment Cluster Change Debt + * + * + * + * @param issuerEventId Ver.: always + * @param debtLabel Ver.: always + * @param debtAmount Ver.: always + * @param debtRecoveryMethod Ver.: always + * @param debtAmountType Ver.: always + * @param debtRecoveryStartTime Ver.: always + * @param debtRecoveryCollectionTime Ver.: always + * @param debtRecoveryFrequency Ver.: always + * @param debtRecoveryAmount Ver.: always + * @param debtRecoveryBalancePercentage Ver.: always + */ +bool emberAfPrepaymentClusterChangeDebtCallback(uint32_t issuerEventId, + uint8_t* debtLabel, + uint32_t debtAmount, + uint8_t debtRecoveryMethod, + uint8_t debtAmountType, + uint32_t debtRecoveryStartTime, + uint16_t debtRecoveryCollectionTime, + uint8_t debtRecoveryFrequency, + uint32_t debtRecoveryAmount, + uint16_t debtRecoveryBalancePercentage); +/** @brief Prepayment Cluster Change Payment Mode + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedPaymentControlConfiguration Ver.: always + * @param cutOffValue Ver.: always + */ +bool emberAfPrepaymentClusterChangePaymentModeCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t implementationDateTime, + uint16_t proposedPaymentControlConfiguration, + uint32_t cutOffValue); +/** @brief Prepayment Cluster Change Payment Mode Response + * + * + * + * @param friendlyCredit Ver.: always + * @param friendlyCreditCalendarId Ver.: always + * @param emergencyCreditLimit Ver.: always + * @param emergencyCreditThreshold Ver.: always + */ +bool emberAfPrepaymentClusterChangePaymentModeResponseCallback(uint8_t friendlyCredit, + uint32_t friendlyCreditCalendarId, + uint32_t emergencyCreditLimit, + uint32_t emergencyCreditThreshold); +/** @brief Prepayment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPrepaymentClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Prepayment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPrepaymentClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Prepayment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPrepaymentClusterClientInitCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPrepaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Prepayment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPrepaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Prepayment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPrepaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Prepayment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPrepaymentClusterClientTickCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Consumer Top Up + * + * + * + * @param originatingDevice Ver.: always + * @param topUpCode Ver.: always + */ +bool emberAfPrepaymentClusterConsumerTopUpCallback(uint8_t originatingDevice, + uint8_t* topUpCode); +/** @brief Prepayment Cluster Consumer Top Up Response + * + * + * + * @param resultType Ver.: always + * @param topUpValue Ver.: always + * @param sourceOfTopUp Ver.: always + * @param creditRemaining Ver.: always + */ +bool emberAfPrepaymentClusterConsumerTopUpResponseCallback(uint8_t resultType, + uint32_t topUpValue, + uint8_t sourceOfTopUp, + uint32_t creditRemaining); +/** @brief Prepayment Cluster Credit Adjustment + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param creditAdjustmentType Ver.: always + * @param creditAdjustmentValue Ver.: always + */ +bool emberAfPrepaymentClusterCreditAdjustmentCallback(uint32_t issuerEventId, + uint32_t startTime, + uint8_t creditAdjustmentType, + uint32_t creditAdjustmentValue); +/** @brief Prepayment Cluster Emergency Credit Setup + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param emergencyCreditLimit Ver.: always + * @param emergencyCreditThreshold Ver.: always + */ +bool emberAfPrepaymentClusterEmergencyCreditSetupCallback(uint32_t issuerEventId, + uint32_t startTime, + uint32_t emergencyCreditLimit, + uint32_t emergencyCreditThreshold); +/** @brief Prepayment Cluster Get Debt Repayment Log + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfDebts Ver.: always + * @param debtType Ver.: always + */ +bool emberAfPrepaymentClusterGetDebtRepaymentLogCallback(uint32_t latestEndTime, + uint8_t numberOfDebts, + uint8_t debtType); +/** @brief Prepayment Cluster Get Prepay Snapshot + * + * + * + * @param earliestStartTime Ver.: always + * @param latestEndTime Ver.: always + * @param snapshotOffset Ver.: always + * @param snapshotCause Ver.: always + */ +bool emberAfPrepaymentClusterGetPrepaySnapshotCallback(uint32_t earliestStartTime, + uint32_t latestEndTime, + uint8_t snapshotOffset, + uint32_t snapshotCause); +/** @brief Prepayment Cluster Get Top Up Log + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfRecords Ver.: always + */ +bool emberAfPrepaymentClusterGetTopUpLogCallback(uint32_t latestEndTime, + uint8_t numberOfRecords); +/** @brief Prepayment Cluster Publish Debt Log + * + * + * + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param debtPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishDebtLogCallback(uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t* debtPayload); +/** @brief Prepayment Cluster Publish Prepay Snapshot + * + * + * + * @param snapshotId Ver.: always + * @param snapshotTime Ver.: always + * @param totalSnapshotsFound Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param snapshotCause Ver.: always + * @param snapshotPayloadType Ver.: always + * @param snapshotPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishPrepaySnapshotCallback(uint32_t snapshotId, + uint32_t snapshotTime, + uint8_t totalSnapshotsFound, + uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint32_t snapshotCause, + uint8_t snapshotPayloadType, + uint8_t* snapshotPayload); +/** @brief Prepayment Cluster Publish Top Up Log + * + * + * + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param topUpPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishTopUpLogCallback(uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t* topUpPayload); +/** @brief Prepayment Cluster Select Available Emergency Credit + * + * + * + * @param commandIssueDateTime Ver.: always + * @param originatingDevice Ver.: always + */ +bool emberAfPrepaymentClusterSelectAvailableEmergencyCreditCallback(uint32_t commandIssueDateTime, + uint8_t originatingDevice); +/** @brief Prepayment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPrepaymentClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Prepayment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPrepaymentClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Prepayment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPrepaymentClusterServerInitCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPrepaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Prepayment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPrepaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Prepayment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPrepaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Prepayment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPrepaymentClusterServerTickCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Set Low Credit Warning Level + * + * + * + * @param lowCreditWarningLevel Ver.: always + */ +bool emberAfPrepaymentClusterSetLowCreditWarningLevelCallback(uint32_t lowCreditWarningLevel); +/** @brief Prepayment Cluster Set Maximum Credit Limit + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param maximumCreditLevel Ver.: always + * @param maximumCreditPerTopUp Ver.: always + */ +bool emberAfPrepaymentClusterSetMaximumCreditLimitCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t implementationDateTime, + uint32_t maximumCreditLevel, + uint32_t maximumCreditPerTopUp); +/** @brief Prepayment Cluster Set Overall Debt Cap + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param overallDebtCap Ver.: always + */ +bool emberAfPrepaymentClusterSetOverallDebtCapCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t implementationDateTime, + uint32_t overallDebtCap); + +/** @} END Prepayment Cluster Callbacks */ + +/** @name Energy Management Cluster Callbacks */ +// @{ + +/** @brief Energy Management Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEnergyManagementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Energy Management Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEnergyManagementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Energy Management Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEnergyManagementClusterClientInitCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEnergyManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Energy Management Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEnergyManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Energy Management Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEnergyManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Energy Management Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEnergyManagementClusterClientTickCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Manage Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param actionRequired Ver.: always + */ +bool emberAfEnergyManagementClusterManageEventCallback(uint32_t issuerEventId, + uint16_t deviceClass, + uint8_t utilityEnrollmentGroup, + uint8_t actionRequired); +/** @brief Energy Management Cluster Report Event Status + * + * + * + * @param issuerEventId Ver.: always + * @param eventStatus Ver.: always + * @param eventStatusTime Ver.: always + * @param criticalityLevelApplied Ver.: always + * @param coolingTemperatureSetPointApplied Ver.: always + * @param heatingTemperatureSetPointApplied Ver.: always + * @param averageLoadAdjustmentPercentageApplied Ver.: always + * @param dutyCycleApplied Ver.: always + * @param eventControl Ver.: always + */ +bool emberAfEnergyManagementClusterReportEventStatusCallback(uint32_t issuerEventId, + uint8_t eventStatus, + uint32_t eventStatusTime, + uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, + uint8_t eventControl); +/** @brief Energy Management Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEnergyManagementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Energy Management Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEnergyManagementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Energy Management Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEnergyManagementClusterServerInitCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEnergyManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Energy Management Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEnergyManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Energy Management Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEnergyManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Energy Management Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEnergyManagementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Energy Management Cluster Callbacks */ + +/** @name Calendar Cluster Callbacks */ +// @{ + +/** @brief Calendar Cluster Cancel Calendar + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param calendarType Ver.: always + */ +bool emberAfCalendarClusterCancelCalendarCallback(uint32_t providerId, + uint32_t issuerCalendarId, + uint8_t calendarType); +/** @brief Calendar Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCalendarClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Calendar Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCalendarClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Calendar Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCalendarClusterClientInitCallback(uint8_t endpoint); +/** @brief Calendar Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCalendarClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Calendar Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCalendarClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Calendar Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCalendarClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Calendar Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCalendarClusterClientTickCallback(uint8_t endpoint); +/** @brief Calendar Cluster Get Calendar + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCalendars Ver.: always + * @param calendarType Ver.: always + * @param providerId Ver.: always + */ +bool emberAfCalendarClusterGetCalendarCallback(uint32_t earliestStartTime, + uint32_t minIssuerEventId, + uint8_t numberOfCalendars, + uint8_t calendarType, + uint32_t providerId); +/** @brief Calendar Cluster Get Calendar Cancellation + * + * + * + */ +bool emberAfCalendarClusterGetCalendarCancellationCallback(void); +/** @brief Calendar Cluster Get Day Profiles + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startDayId Ver.: always + * @param numberOfDays Ver.: always + */ +bool emberAfCalendarClusterGetDayProfilesCallback(uint32_t providerId, + uint32_t issuerCalendarId, + uint8_t startDayId, + uint8_t numberOfDays); +/** @brief Calendar Cluster Get Seasons + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + */ +bool emberAfCalendarClusterGetSeasonsCallback(uint32_t providerId, + uint32_t issuerCalendarId); +/** @brief Calendar Cluster Get Special Days + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param calendarType Ver.: always + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + */ +bool emberAfCalendarClusterGetSpecialDaysCallback(uint32_t startTime, + uint8_t numberOfEvents, + uint8_t calendarType, + uint32_t providerId, + uint32_t issuerCalendarId); +/** @brief Calendar Cluster Get Week Profiles + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startWeekId Ver.: always + * @param numberOfWeeks Ver.: always + */ +bool emberAfCalendarClusterGetWeekProfilesCallback(uint32_t providerId, + uint32_t issuerCalendarId, + uint8_t startWeekId, + uint8_t numberOfWeeks); +/** @brief Calendar Cluster Publish Calendar + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startTime Ver.: always + * @param calendarType Ver.: always + * @param calendarTimeReference Ver.: always + * @param calendarName Ver.: always + * @param numberOfSeasons Ver.: always + * @param numberOfWeekProfiles Ver.: always + * @param numberOfDayProfiles Ver.: always + */ +bool emberAfCalendarClusterPublishCalendarCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerCalendarId, + uint32_t startTime, + uint8_t calendarType, + uint8_t calendarTimeReference, + uint8_t* calendarName, + uint8_t numberOfSeasons, + uint8_t numberOfWeekProfiles, + uint8_t numberOfDayProfiles); +/** @brief Calendar Cluster Publish Day Profile + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param dayId Ver.: always + * @param totalNumberOfScheduleEntries Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param calendarType Ver.: always + * @param dayScheduleEntries Ver.: always + */ +bool emberAfCalendarClusterPublishDayProfileCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerCalendarId, + uint8_t dayId, + uint8_t totalNumberOfScheduleEntries, + uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t calendarType, + uint8_t* dayScheduleEntries); +/** @brief Calendar Cluster Publish Seasons + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param seasonEntries Ver.: always + */ +bool emberAfCalendarClusterPublishSeasonsCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerCalendarId, + uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t* seasonEntries); +/** @brief Calendar Cluster Publish Special Days + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startTime Ver.: always + * @param calendarType Ver.: always + * @param totalNumberOfSpecialDays Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param specialDayEntries Ver.: always + */ +bool emberAfCalendarClusterPublishSpecialDaysCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerCalendarId, + uint32_t startTime, + uint8_t calendarType, + uint8_t totalNumberOfSpecialDays, + uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t* specialDayEntries); +/** @brief Calendar Cluster Publish Week Profile + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param weekId Ver.: always + * @param dayIdRefMonday Ver.: always + * @param dayIdRefTuesday Ver.: always + * @param dayIdRefWednesday Ver.: always + * @param dayIdRefThursday Ver.: always + * @param dayIdRefFriday Ver.: always + * @param dayIdRefSaturday Ver.: always + * @param dayIdRefSunday Ver.: always + */ +bool emberAfCalendarClusterPublishWeekProfileCallback(uint32_t providerId, + uint32_t issuerEventId, + uint32_t issuerCalendarId, + uint8_t weekId, + uint8_t dayIdRefMonday, + uint8_t dayIdRefTuesday, + uint8_t dayIdRefWednesday, + uint8_t dayIdRefThursday, + uint8_t dayIdRefFriday, + uint8_t dayIdRefSaturday, + uint8_t dayIdRefSunday); +/** @brief Calendar Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCalendarClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Calendar Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCalendarClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Calendar Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCalendarClusterServerInitCallback(uint8_t endpoint); +/** @brief Calendar Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCalendarClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Calendar Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCalendarClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Calendar Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCalendarClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Calendar Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCalendarClusterServerTickCallback(uint8_t endpoint); + +/** @} END Calendar Cluster Callbacks */ + +/** @name Device Management Cluster Callbacks */ +// @{ + +/** @brief Device Management Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceManagementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Device Management Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceManagementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Device Management Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceManagementClusterClientInitCallback(uint8_t endpoint); +/** @brief Device Management Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Management Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Device Management Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Device Management Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceManagementClusterClientTickCallback(uint8_t endpoint); +/** @brief Device Management Cluster Get C I N + * + * + * + */ +bool emberAfDeviceManagementClusterGetCINCallback(void); +/** @brief Device Management Cluster Get Change Of Supplier + * + * + * + */ +bool emberAfDeviceManagementClusterGetChangeOfSupplierCallback(void); +/** @brief Device Management Cluster Get Change Of Tenancy + * + * + * + */ +bool emberAfDeviceManagementClusterGetChangeOfTenancyCallback(void); +/** @brief Device Management Cluster Get Event Configuration + * + * + * + * @param eventId Ver.: always + */ +bool emberAfDeviceManagementClusterGetEventConfigurationCallback(uint16_t eventId); +/** @brief Device Management Cluster Get Site Id + * + * + * + */ +bool emberAfDeviceManagementClusterGetSiteIdCallback(void); +/** @brief Device Management Cluster Publish Change Of Supplier + * + * + * + * @param currentProviderId Ver.: always + * @param issuerEventId Ver.: always + * @param tariffType Ver.: always + * @param proposedProviderId Ver.: always + * @param providerChangeImplementationTime Ver.: always + * @param providerChangeControl Ver.: always + * @param proposedProviderName Ver.: always + * @param proposedProviderContactDetails Ver.: always + */ +bool emberAfDeviceManagementClusterPublishChangeOfSupplierCallback(uint32_t currentProviderId, + uint32_t issuerEventId, + uint8_t tariffType, + uint32_t proposedProviderId, + uint32_t providerChangeImplementationTime, + uint32_t providerChangeControl, + uint8_t* proposedProviderName, + uint8_t* proposedProviderContactDetails); +/** @brief Device Management Cluster Publish Change Of Tenancy + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param tariffType Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedTenancyChangeControl Ver.: always + */ +bool emberAfDeviceManagementClusterPublishChangeOfTenancyCallback(uint32_t providerId, + uint32_t issuerEventId, + uint8_t tariffType, + uint32_t implementationDateTime, + uint32_t proposedTenancyChangeControl); +/** @brief Device Management Cluster Report Event Configuration + * + * + * + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param eventConfigurationPayload Ver.: always + */ +bool emberAfDeviceManagementClusterReportEventConfigurationCallback(uint8_t commandIndex, + uint8_t totalCommands, + uint8_t* eventConfigurationPayload); +/** @brief Device Management Cluster Request New Password + * + * + * + * @param passwordType Ver.: always + */ +bool emberAfDeviceManagementClusterRequestNewPasswordCallback(uint8_t passwordType); +/** @brief Device Management Cluster Request New Password Response + * + * + * + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param durationInMinutes Ver.: always + * @param passwordType Ver.: always + * @param password Ver.: always + */ +bool emberAfDeviceManagementClusterRequestNewPasswordResponseCallback(uint32_t issuerEventId, + uint32_t implementationDateTime, + uint16_t durationInMinutes, + uint8_t passwordType, + uint8_t* password); +/** @brief Device Management Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceManagementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Device Management Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceManagementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Device Management Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceManagementClusterServerInitCallback(uint8_t endpoint); +/** @brief Device Management Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Management Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Device Management Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Device Management Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceManagementClusterServerTickCallback(uint8_t endpoint); +/** @brief Device Management Cluster Set Event Configuration + * + * + * + * @param issuerEventId Ver.: always + * @param startDateTime Ver.: always + * @param eventConfiguration Ver.: always + * @param configurationControl Ver.: always + * @param eventConfigurationPayload Ver.: always + */ +bool emberAfDeviceManagementClusterSetEventConfigurationCallback(uint32_t issuerEventId, + uint32_t startDateTime, + uint8_t eventConfiguration, + uint8_t configurationControl, + uint8_t* eventConfigurationPayload); +/** @brief Device Management Cluster Update C I N + * + * + * + * @param issuerEventId Ver.: always + * @param implementationTime Ver.: always + * @param providerId Ver.: always + * @param customerIdNumber Ver.: always + */ +bool emberAfDeviceManagementClusterUpdateCINCallback(uint32_t issuerEventId, + uint32_t implementationTime, + uint32_t providerId, + uint8_t* customerIdNumber); +/** @brief Device Management Cluster Update Site Id + * + * + * + * @param issuerEventId Ver.: always + * @param siteIdTime Ver.: always + * @param providerId Ver.: always + * @param siteId Ver.: always + */ +bool emberAfDeviceManagementClusterUpdateSiteIdCallback(uint32_t issuerEventId, + uint32_t siteIdTime, + uint32_t providerId, + uint8_t* siteId); + +/** @} END Device Management Cluster Callbacks */ + +/** @name Events Cluster Callbacks */ +// @{ + +/** @brief Events Cluster Clear Event Log Request + * + * + * + * @param logId Ver.: always + */ +bool emberAfEventsClusterClearEventLogRequestCallback(uint8_t logId); +/** @brief Events Cluster Clear Event Log Response + * + * + * + * @param clearedEventsLogs Ver.: always + */ +bool emberAfEventsClusterClearEventLogResponseCallback(uint8_t clearedEventsLogs); +/** @brief Events Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEventsClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Events Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEventsClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Events Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEventsClusterClientInitCallback(uint8_t endpoint); +/** @brief Events Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEventsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Events Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEventsClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Events Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEventsClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Events Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEventsClusterClientTickCallback(uint8_t endpoint); +/** @brief Events Cluster Get Event Log + * + * + * + * @param eventControlLogId Ver.: always + * @param eventId Ver.: always + * @param startTime Ver.: always + * @param endTime Ver.: always + * @param numberOfEvents Ver.: always + * @param eventOffset Ver.: always + */ +bool emberAfEventsClusterGetEventLogCallback(uint8_t eventControlLogId, + uint16_t eventId, + uint32_t startTime, + uint32_t endTime, + uint8_t numberOfEvents, + uint16_t eventOffset); +/** @brief Events Cluster Publish Event + * + * + * + * @param logId Ver.: always + * @param eventId Ver.: always + * @param eventTime Ver.: always + * @param eventControl Ver.: always + * @param eventData Ver.: always + */ +bool emberAfEventsClusterPublishEventCallback(uint8_t logId, + uint16_t eventId, + uint32_t eventTime, + uint8_t eventControl, + uint8_t* eventData); +/** @brief Events Cluster Publish Event Log + * + * + * + * @param totalNumberOfEvents Ver.: always + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param logPayloadControl Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfEventsClusterPublishEventLogCallback(uint16_t totalNumberOfEvents, + uint8_t commandIndex, + uint8_t totalCommands, + uint8_t logPayloadControl, + uint8_t* logPayload); +/** @brief Events Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEventsClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Events Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEventsClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Events Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEventsClusterServerInitCallback(uint8_t endpoint); +/** @brief Events Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEventsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Events Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEventsClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Events Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEventsClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Events Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEventsClusterServerTickCallback(uint8_t endpoint); + +/** @} END Events Cluster Callbacks */ + +/** @name MDU Pairing Cluster Callbacks */ +// @{ + +/** @brief MDU Pairing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMduPairingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief MDU Pairing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMduPairingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief MDU Pairing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMduPairingClusterClientInitCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMduPairingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MDU Pairing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMduPairingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief MDU Pairing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMduPairingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief MDU Pairing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMduPairingClusterClientTickCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Pairing Request + * + * + * + * @param localPairingInformationVersion Ver.: always + * @param eui64OfRequestingDevice Ver.: always + */ +bool emberAfMduPairingClusterPairingRequestCallback(uint32_t localPairingInformationVersion, + uint8_t* eui64OfRequestingDevice); +/** @brief MDU Pairing Cluster Pairing Response + * + * + * + * @param pairingInformationVersion Ver.: always + * @param totalNumberOfDevices Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param eui64s Ver.: always + */ +bool emberAfMduPairingClusterPairingResponseCallback(uint32_t pairingInformationVersion, + uint8_t totalNumberOfDevices, + uint8_t commandIndex, + uint8_t totalNumberOfCommands, + uint8_t* eui64s); +/** @brief MDU Pairing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMduPairingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief MDU Pairing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMduPairingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief MDU Pairing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMduPairingClusterServerInitCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMduPairingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MDU Pairing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMduPairingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief MDU Pairing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMduPairingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief MDU Pairing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMduPairingClusterServerTickCallback(uint8_t endpoint); + +/** @} END MDU Pairing Cluster Callbacks */ + +/** @name Sub-GHz Cluster Callbacks */ +// @{ + +/** @brief Sub-GHz Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSubGhzClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sub-GHz Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSubGhzClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sub-GHz Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSubGhzClusterClientInitCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSubGhzClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sub-GHz Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSubGhzClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sub-GHz Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSubGhzClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sub-GHz Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSubGhzClusterClientTickCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Get Suspend Zcl Messages Status + * + * + * + */ +bool emberAfSubGhzClusterGetSuspendZclMessagesStatusCallback(void); +/** @brief Sub-GHz Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSubGhzClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sub-GHz Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSubGhzClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sub-GHz Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSubGhzClusterServerInitCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSubGhzClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sub-GHz Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSubGhzClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sub-GHz Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSubGhzClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sub-GHz Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSubGhzClusterServerTickCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Suspend Zcl Messages + * + * + * + * @param period Ver.: always + */ +bool emberAfSubGhzClusterSuspendZclMessagesCallback(uint8_t period); + +/** @} END Sub-GHz Cluster Callbacks */ + +/** @name Key Establishment Cluster Callbacks */ +// @{ + +/** @brief Key Establishment Cluster Client Command Received + * + * This function is called by the application framework when a server-to-client + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand *cmd); +/** @brief Key Establishment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeyEstablishmentClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Key Establishment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeyEstablishmentClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Key Establishment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeyEstablishmentClusterClientInitCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeyEstablishmentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Key Establishment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeyEstablishmentClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Key Establishment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeyEstablishmentClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Key Establishment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeyEstablishmentClusterClientTickCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Confirm Key Data Request + * + * + * + * @param secureMessageAuthenticationCode Ver.: always + */ +bool emberAfKeyEstablishmentClusterConfirmKeyDataRequestCallback(uint8_t* secureMessageAuthenticationCode); +/** @brief Key Establishment Cluster Confirm Key Data Response + * + * + * + * @param secureMessageAuthenticationCode Ver.: always + */ +bool emberAfKeyEstablishmentClusterConfirmKeyDataResponseCallback(uint8_t* secureMessageAuthenticationCode); +/** @brief Key Establishment Cluster Ephemeral Data Request + * + * + * + * @param ephemeralData Ver.: always + */ +bool emberAfKeyEstablishmentClusterEphemeralDataRequestCallback(uint8_t* ephemeralData); +/** @brief Key Establishment Cluster Ephemeral Data Response + * + * + * + * @param ephemeralData Ver.: always + */ +bool emberAfKeyEstablishmentClusterEphemeralDataResponseCallback(uint8_t* ephemeralData); +/** @brief Key Establishment Cluster Initiate Key Establishment Request + * + * + * + * @param keyEstablishmentSuite Ver.: always + * @param ephemeralDataGenerateTime Ver.: always + * @param confirmKeyGenerateTime Ver.: always + * @param identity Ver.: always + */ +bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentRequestCallback(uint16_t keyEstablishmentSuite, + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, + uint8_t* identity); +/** @brief Key Establishment Cluster Initiate Key Establishment Response + * + * + * + * @param requestedKeyEstablishmentSuite Ver.: always + * @param ephemeralDataGenerateTime Ver.: always + * @param confirmKeyGenerateTime Ver.: always + * @param identity Ver.: always + */ +bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentResponseCallback(uint16_t requestedKeyEstablishmentSuite, + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, + uint8_t* identity); +/** @brief Key Establishment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeyEstablishmentClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Key Establishment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeyEstablishmentClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Key Establishment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeyEstablishmentClusterServerInitCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeyEstablishmentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Key Establishment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeyEstablishmentClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Key Establishment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeyEstablishmentClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Key Establishment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeyEstablishmentClusterServerTickCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Terminate Key Establishment + * + * + * + * @param statusCode Ver.: always + * @param waitTime Ver.: always + * @param keyEstablishmentSuite Ver.: always + */ +bool emberAfKeyEstablishmentClusterTerminateKeyEstablishmentCallback(uint8_t statusCode, + uint8_t waitTime, + uint16_t keyEstablishmentSuite); +/** @brief Key Establishment Cluster Server Command Received + * + * This function is called by the application framework when a client-to-server + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand *cmd); + +/** @} END Key Establishment Cluster Callbacks */ + +/** @name Information Cluster Callbacks */ +// @{ + +/** @brief Information Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfInformationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Information Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfInformationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Information Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfInformationClusterClientInitCallback(uint8_t endpoint); +/** @brief Information Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfInformationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Information Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfInformationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Information Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfInformationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Information Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfInformationClusterClientTickCallback(uint8_t endpoint); +/** @brief Information Cluster Configure Delivery Enable + * + * + * + * @param enable Ver.: always + */ +bool emberAfInformationClusterConfigureDeliveryEnableCallback(uint8_t enable); +/** @brief Information Cluster Configure Node Description + * + * + * + * @param description Ver.: always + */ +bool emberAfInformationClusterConfigureNodeDescriptionCallback(uint8_t* description); +/** @brief Information Cluster Configure Push Information Timer + * + * + * + * @param timer Ver.: always + */ +bool emberAfInformationClusterConfigurePushInformationTimerCallback(uint32_t timer); +/** @brief Information Cluster Configure Set Root Id + * + * + * + * @param rootId Ver.: always + */ +bool emberAfInformationClusterConfigureSetRootIdCallback(uint16_t rootId); +/** @brief Information Cluster Delete + * + * + * + * @param deletionOptions Ver.: always + * @param contentIds Ver.: always + */ +bool emberAfInformationClusterDeleteCallback(uint8_t deletionOptions, + uint8_t* contentIds); +/** @brief Information Cluster Delete Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterDeleteResponseCallback(uint8_t* notificationList); +/** @brief Information Cluster Push Information + * + * + * + * @param contents Ver.: always + */ +bool emberAfInformationClusterPushInformationCallback(uint8_t* contents); +/** @brief Information Cluster Push Information Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterPushInformationResponseCallback(uint8_t* notificationList); +/** @brief Information Cluster Request Information + * + * + * + * @param inquiryId Ver.: always + * @param dataTypeId Ver.: always + * @param requestInformationPayload Ver.: always + */ +bool emberAfInformationClusterRequestInformationCallback(uint8_t inquiryId, + uint8_t dataTypeId, + uint8_t* requestInformationPayload); +/** @brief Information Cluster Request Information Response + * + * + * + * @param number Ver.: always + * @param buffer Ver.: always + */ +bool emberAfInformationClusterRequestInformationResponseCallback(uint8_t number, + uint8_t* buffer); +/** @brief Information Cluster Request Preference Confirmation + * + * + * + * @param statusFeedbackList Ver.: always + */ +bool emberAfInformationClusterRequestPreferenceConfirmationCallback(uint8_t* statusFeedbackList); +/** @brief Information Cluster Request Preference Response + * + * + * + * @param statusFeedback Ver.: always + * @param preferenceType Ver.: always + * @param preferencePayload Ver.: always + */ +bool emberAfInformationClusterRequestPreferenceResponseCallback(uint8_t statusFeedback, + uint16_t preferenceType, + uint8_t* preferencePayload); +/** @brief Information Cluster Send Preference + * + * + * + * @param preferenceType Ver.: always + * @param preferencePayload Ver.: always + */ +bool emberAfInformationClusterSendPreferenceCallback(uint16_t preferenceType, + uint8_t* preferencePayload); +/** @brief Information Cluster Send Preference Response + * + * + * + * @param statusFeedbackList Ver.: always + */ +bool emberAfInformationClusterSendPreferenceResponseCallback(uint8_t* statusFeedbackList); +/** @brief Information Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfInformationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Information Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfInformationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Information Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfInformationClusterServerInitCallback(uint8_t endpoint); +/** @brief Information Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfInformationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Information Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfInformationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Information Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfInformationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Information Cluster Server Request Preference + * + * + * + */ +bool emberAfInformationClusterServerRequestPreferenceCallback(void); +/** @brief Information Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfInformationClusterServerTickCallback(uint8_t endpoint); +/** @brief Information Cluster Update + * + * + * + * @param accessControl Ver.: always + * @param option Ver.: always + * @param contents Ver.: always + */ +bool emberAfInformationClusterUpdateCallback(uint8_t accessControl, + uint8_t option, + uint8_t* contents); +/** @brief Information Cluster Update Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterUpdateResponseCallback(uint8_t* notificationList); + +/** @} END Information Cluster Callbacks */ + +/** @name Data Sharing Cluster Callbacks */ +// @{ + +/** @brief Data Sharing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataSharingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Data Sharing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataSharingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Data Sharing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataSharingClusterClientInitCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataSharingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Sharing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataSharingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Data Sharing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataSharingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Data Sharing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataSharingClusterClientTickCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster File Transmission + * + * + * + * @param transmitOptions Ver.: always + * @param buffer Ver.: always + */ +bool emberAfDataSharingClusterFileTransmissionCallback(uint8_t transmitOptions, + uint8_t* buffer); +/** @brief Data Sharing Cluster Modify File Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartPosition Ver.: always + * @param octetCount Ver.: always + */ +bool emberAfDataSharingClusterModifyFileRequestCallback(uint16_t fileIndex, + uint32_t fileStartPosition, + uint32_t octetCount); +/** @brief Data Sharing Cluster Modify Record Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartRecord Ver.: always + * @param recordCount Ver.: always + */ +bool emberAfDataSharingClusterModifyRecordRequestCallback(uint16_t fileIndex, + uint16_t fileStartRecord, + uint16_t recordCount); +/** @brief Data Sharing Cluster Read File Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartPositionAndRequestedOctetCount Ver.: always + */ +bool emberAfDataSharingClusterReadFileRequestCallback(uint16_t fileIndex, + uint8_t* fileStartPositionAndRequestedOctetCount); +/** @brief Data Sharing Cluster Read Record Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartRecordAndRequestedRecordCount Ver.: always + */ +bool emberAfDataSharingClusterReadRecordRequestCallback(uint16_t fileIndex, + uint8_t* fileStartRecordAndRequestedRecordCount); +/** @brief Data Sharing Cluster Record Transmission + * + * + * + * @param transmitOptions Ver.: always + * @param buffer Ver.: always + */ +bool emberAfDataSharingClusterRecordTransmissionCallback(uint8_t transmitOptions, + uint8_t* buffer); +/** @brief Data Sharing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataSharingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Data Sharing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataSharingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Data Sharing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataSharingClusterServerInitCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataSharingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Sharing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataSharingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Data Sharing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataSharingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Data Sharing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataSharingClusterServerTickCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Write File Request + * + * + * + * @param writeOptions Ver.: always + * @param fileSize Ver.: always + */ +bool emberAfDataSharingClusterWriteFileRequestCallback(uint8_t writeOptions, + uint8_t* fileSize); +/** @brief Data Sharing Cluster Write File Response + * + * + * + * @param status Ver.: always + * @param fileIndex Ver.: always + */ +bool emberAfDataSharingClusterWriteFileResponseCallback(uint8_t status, + uint8_t* fileIndex); + +/** @} END Data Sharing Cluster Callbacks */ + +/** @name Gaming Cluster Callbacks */ +// @{ + +/** @brief Gaming Cluster Action Control + * + * + * + * @param actions Ver.: always + */ +bool emberAfGamingClusterActionControlCallback(uint32_t actions); +/** @brief Gaming Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGamingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Gaming Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGamingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Gaming Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGamingClusterClientInitCallback(uint8_t endpoint); +/** @brief Gaming Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGamingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Gaming Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGamingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Gaming Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGamingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Gaming Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGamingClusterClientTickCallback(uint8_t endpoint); +/** @brief Gaming Cluster Download Game + * + * + * + */ +bool emberAfGamingClusterDownloadGameCallback(void); +/** @brief Gaming Cluster End Game + * + * + * + */ +bool emberAfGamingClusterEndGameCallback(void); +/** @brief Gaming Cluster Game Announcement + * + * + * + * @param gameId Ver.: always + * @param gameMaster Ver.: always + * @param listOfGame Ver.: always + */ +bool emberAfGamingClusterGameAnnouncementCallback(uint16_t gameId, + uint8_t gameMaster, + uint8_t* listOfGame); +/** @brief Gaming Cluster General Response + * + * + * + * @param commandId Ver.: always + * @param status Ver.: always + * @param message Ver.: always + */ +bool emberAfGamingClusterGeneralResponseCallback(uint8_t commandId, + uint8_t status, + uint8_t* message); +/** @brief Gaming Cluster Join Game + * + * + * + * @param gameId Ver.: always + * @param joinAsMaster Ver.: always + * @param nameOfGame Ver.: always + */ +bool emberAfGamingClusterJoinGameCallback(uint16_t gameId, + uint8_t joinAsMaster, + uint8_t* nameOfGame); +/** @brief Gaming Cluster Pause Game + * + * + * + */ +bool emberAfGamingClusterPauseGameCallback(void); +/** @brief Gaming Cluster Quit Game + * + * + * + */ +bool emberAfGamingClusterQuitGameCallback(void); +/** @brief Gaming Cluster Resume Game + * + * + * + */ +bool emberAfGamingClusterResumeGameCallback(void); +/** @brief Gaming Cluster Search Game + * + * + * + * @param specificGame Ver.: always + * @param gameId Ver.: always + */ +bool emberAfGamingClusterSearchGameCallback(uint8_t specificGame, + uint16_t gameId); +/** @brief Gaming Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGamingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Gaming Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGamingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Gaming Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGamingClusterServerInitCallback(uint8_t endpoint); +/** @brief Gaming Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGamingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Gaming Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGamingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Gaming Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGamingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Gaming Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGamingClusterServerTickCallback(uint8_t endpoint); +/** @brief Gaming Cluster Start Game + * + * + * + */ +bool emberAfGamingClusterStartGameCallback(void); +/** @brief Gaming Cluster Start Over + * + * + * + */ +bool emberAfGamingClusterStartOverCallback(void); + +/** @} END Gaming Cluster Callbacks */ + +/** @name Data Rate Control Cluster Callbacks */ +// @{ + +/** @brief Data Rate Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataRateControlClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Data Rate Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataRateControlClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Data Rate Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataRateControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataRateControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Rate Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataRateControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Data Rate Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataRateControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Data Rate Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataRateControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Data Rate Control + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterDataRateControlCallback(uint16_t originatorAddress, + uint16_t destinationAddress, + uint8_t dataRate); +/** @brief Data Rate Control Cluster Data Rate Notification + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterDataRateNotificationCallback(uint16_t originatorAddress, + uint16_t destinationAddress, + uint8_t dataRate); +/** @brief Data Rate Control Cluster Path Creation + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterPathCreationCallback(uint16_t originatorAddress, + uint16_t destinationAddress, + uint8_t dataRate); +/** @brief Data Rate Control Cluster Path Deletion + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + */ +bool emberAfDataRateControlClusterPathDeletionCallback(uint16_t originatorAddress, + uint16_t destinationAddress); +/** @brief Data Rate Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataRateControlClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Data Rate Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataRateControlClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Data Rate Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataRateControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataRateControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Rate Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataRateControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Data Rate Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataRateControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Data Rate Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataRateControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Data Rate Control Cluster Callbacks */ + +/** @name Voice over ZigBee Cluster Callbacks */ +// @{ + +/** @brief Voice over ZigBee Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Voice over ZigBee Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Voice over ZigBee Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientInitCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Voice over ZigBee Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Voice over ZigBee Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfVoiceOverZigbeeClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Voice over ZigBee Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientTickCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Control + * + * + * + * @param controlType Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterControlCallback(uint8_t controlType); +/** @brief Voice over ZigBee Cluster Control Response + * + * + * + * @param ackNack Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterControlResponseCallback(uint8_t ackNack); +/** @brief Voice over ZigBee Cluster Establishment Request + * + * + * + * @param flag Ver.: always + * @param codecType Ver.: always + * @param sampFreq Ver.: always + * @param codecRate Ver.: always + * @param serviceType Ver.: always + * @param buffer Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterEstablishmentRequestCallback(uint8_t flag, + uint8_t codecType, + uint8_t sampFreq, + uint8_t codecRate, + uint8_t serviceType, + uint8_t* buffer); +/** @brief Voice over ZigBee Cluster Establishment Response + * + * + * + * @param ackNack Ver.: always + * @param codecType Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterEstablishmentResponseCallback(uint8_t ackNack, + uint8_t codecType); +/** @brief Voice over ZigBee Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Voice over ZigBee Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Voice over ZigBee Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerInitCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Voice over ZigBee Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Voice over ZigBee Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfVoiceOverZigbeeClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Voice over ZigBee Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerTickCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Voice Transmission + * + * + * + * @param voiceData Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCallback(uint8_t* voiceData); +/** @brief Voice over ZigBee Cluster Voice Transmission Completion + * + * + * + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCompletionCallback(void); +/** @brief Voice over ZigBee Cluster Voice Transmission Response + * + * + * + * @param sequenceNumber Ver.: always + * @param errorFlag Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequenceNumber, + uint8_t errorFlag); + +/** @} END Voice over ZigBee Cluster Callbacks */ + +/** @name Chatting Cluster Callbacks */ +// @{ + +/** @brief Chatting Cluster Chat Message + * + * + * + * @param destinationUid Ver.: always + * @param sourceUid Ver.: always + * @param cid Ver.: always + * @param nickname Ver.: always + * @param message Ver.: always + */ +bool emberAfChattingClusterChatMessageCallback(uint16_t destinationUid, + uint16_t sourceUid, + uint16_t cid, + uint8_t* nickname, + uint8_t* message); +/** @brief Chatting Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChattingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chatting Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChattingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chatting Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChattingClusterClientInitCallback(uint8_t endpoint); +/** @brief Chatting Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChattingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chatting Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChattingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chatting Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChattingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chatting Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChattingClusterClientTickCallback(uint8_t endpoint); +/** @brief Chatting Cluster Get Node Information Request + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterGetNodeInformationRequestCallback(uint16_t cid, + uint16_t uid); +/** @brief Chatting Cluster Get Node Information Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + * @param uid Ver.: always + * @param addressEndpointAndNickname Ver.: always + */ +bool emberAfChattingClusterGetNodeInformationResponseCallback(uint8_t status, + uint16_t cid, + uint16_t uid, + uint8_t* addressEndpointAndNickname); +/** @brief Chatting Cluster Join Chat Request + * + * + * + * @param uid Ver.: always + * @param nickname Ver.: always + * @param cid Ver.: always + */ +bool emberAfChattingClusterJoinChatRequestCallback(uint16_t uid, + uint8_t* nickname, + uint16_t cid); +/** @brief Chatting Cluster Join Chat Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + * @param chatParticipantList Ver.: always + */ +bool emberAfChattingClusterJoinChatResponseCallback(uint8_t status, + uint16_t cid, + uint8_t* chatParticipantList); +/** @brief Chatting Cluster Leave Chat Request + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterLeaveChatRequestCallback(uint16_t cid, + uint16_t uid); +/** @brief Chatting Cluster Search Chat Request + * + * + * + */ +bool emberAfChattingClusterSearchChatRequestCallback(void); +/** @brief Chatting Cluster Search Chat Response + * + * + * + * @param options Ver.: always + * @param chatRoomList Ver.: always + */ +bool emberAfChattingClusterSearchChatResponseCallback(uint8_t options, + uint8_t* chatRoomList); +/** @brief Chatting Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChattingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chatting Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChattingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Chatting Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChattingClusterServerInitCallback(uint8_t endpoint); +/** @brief Chatting Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChattingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chatting Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChattingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Chatting Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChattingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Chatting Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChattingClusterServerTickCallback(uint8_t endpoint); +/** @brief Chatting Cluster Start Chat Request + * + * + * + * @param name Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterStartChatRequestCallback(uint8_t* name, + uint16_t uid, + uint8_t* nickname); +/** @brief Chatting Cluster Start Chat Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + */ +bool emberAfChattingClusterStartChatResponseCallback(uint8_t status, + uint16_t cid); +/** @brief Chatting Cluster Switch Chairman Confirm + * + * + * + * @param cid Ver.: always + * @param nodeInformationList Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanConfirmCallback(uint16_t cid, + uint8_t* nodeInformationList); +/** @brief Chatting Cluster Switch Chairman Notification + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param address Ver.: always + * @param endpoint Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanNotificationCallback(uint16_t cid, + uint16_t uid, + uint16_t address, + uint8_t endpoint); +/** @brief Chatting Cluster Switch Chairman Request + * + * + * + * @param cid Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanRequestCallback(uint16_t cid); +/** @brief Chatting Cluster Switch Chairman Response + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanResponseCallback(uint16_t cid, + uint16_t uid); +/** @brief Chatting Cluster User Joined + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterUserJoinedCallback(uint16_t cid, + uint16_t uid, + uint8_t* nickname); +/** @brief Chatting Cluster User Left + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterUserLeftCallback(uint16_t cid, + uint16_t uid, + uint8_t* nickname); + +/** @} END Chatting Cluster Callbacks */ + +/** @name Payment Cluster Callbacks */ +// @{ + +/** @brief Payment Cluster Accept Payment + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + * @param serviceId Ver.: always + * @param goodId Ver.: always + */ +bool emberAfPaymentClusterAcceptPaymentCallback(uint8_t* userId, + uint16_t userType, + uint16_t serviceId, + uint8_t* goodId); +/** @brief Payment Cluster Buy Confirm + * + * + * + * @param serialNumber Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param price Ver.: always + * @param timestamp Ver.: always + * @param transId Ver.: always + * @param transStatus Ver.: always + */ +bool emberAfPaymentClusterBuyConfirmCallback(uint8_t* serialNumber, + uint32_t currency, + uint8_t priceTrailingDigit, + uint32_t price, + uint8_t* timestamp, + uint16_t transId, + uint8_t transStatus); +/** @brief Payment Cluster Buy Request + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + * @param serviceId Ver.: always + * @param goodId Ver.: always + */ +bool emberAfPaymentClusterBuyRequestCallback(uint8_t* userId, + uint16_t userType, + uint16_t serviceId, + uint8_t* goodId); +/** @brief Payment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPaymentClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Payment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPaymentClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Payment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPaymentClusterClientInitCallback(uint8_t endpoint); +/** @brief Payment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Payment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Payment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Payment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPaymentClusterClientTickCallback(uint8_t endpoint); +/** @brief Payment Cluster Payment Confirm + * + * + * + * @param serialNumber Ver.: always + * @param transId Ver.: always + * @param transStatus Ver.: always + */ +bool emberAfPaymentClusterPaymentConfirmCallback(uint8_t* serialNumber, + uint16_t transId, + uint8_t transStatus); +/** @brief Payment Cluster Receipt Delivery + * + * + * + * @param serialNumber Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param price Ver.: always + * @param timestamp Ver.: always + */ +bool emberAfPaymentClusterReceiptDeliveryCallback(uint8_t* serialNumber, + uint32_t currency, + uint8_t priceTrailingDigit, + uint32_t price, + uint8_t* timestamp); +/** @brief Payment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPaymentClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Payment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPaymentClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Payment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPaymentClusterServerInitCallback(uint8_t endpoint); +/** @brief Payment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Payment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Payment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Payment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPaymentClusterServerTickCallback(uint8_t endpoint); +/** @brief Payment Cluster Transaction End + * + * + * + * @param serialNumber Ver.: always + * @param status Ver.: always + */ +bool emberAfPaymentClusterTransactionEndCallback(uint8_t* serialNumber, + uint8_t status); + +/** @} END Payment Cluster Callbacks */ + +/** @name Billing Cluster Callbacks */ +// @{ + +/** @brief Billing Cluster Bill Status Notification + * + * + * + * @param userId Ver.: always + * @param status Ver.: always + */ +bool emberAfBillingClusterBillStatusNotificationCallback(uint8_t* userId, + uint8_t status); +/** @brief Billing Cluster Check Bill Status + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterCheckBillStatusCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); +/** @brief Billing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBillingClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Billing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBillingClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Billing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBillingClusterClientInitCallback(uint8_t endpoint); +/** @brief Billing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBillingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Billing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBillingClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Billing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBillingClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Billing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBillingClusterClientTickCallback(uint8_t endpoint); +/** @brief Billing Cluster Send Bill Record + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + * @param timestamp Ver.: always + * @param duration Ver.: always + */ +bool emberAfBillingClusterSendBillRecordCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId, + uint8_t* timestamp, + uint16_t duration); +/** @brief Billing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBillingClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Billing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBillingClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Billing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBillingClusterServerInitCallback(uint8_t endpoint); +/** @brief Billing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBillingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Billing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBillingClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Billing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBillingClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Billing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBillingClusterServerTickCallback(uint8_t endpoint); +/** @brief Billing Cluster Session Keep Alive + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterSessionKeepAliveCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); +/** @brief Billing Cluster Start Billing Session + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterStartBillingSessionCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); +/** @brief Billing Cluster Stop Billing Session + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterStopBillingSessionCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); +/** @brief Billing Cluster Subscribe + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterSubscribeCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); +/** @brief Billing Cluster Unsubscribe + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterUnsubscribeCallback(uint8_t* userId, + uint16_t serviceId, + uint16_t serviceProviderId); + +/** @} END Billing Cluster Callbacks */ + +/** @name Appliance Identification Cluster Callbacks */ +// @{ + +/** @brief Appliance Identification Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Identification Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Identification Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceIdentificationClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Identification Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Identification Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Identification Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceIdentificationClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Identification Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Identification Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceIdentificationClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Identification Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Identification Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Identification Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceIdentificationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Appliance Identification Cluster Callbacks */ + +/** @name Meter Identification Cluster Callbacks */ +// @{ + +/** @brief Meter Identification Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMeterIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Meter Identification Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMeterIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Meter Identification Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMeterIdentificationClusterClientInitCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMeterIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Meter Identification Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMeterIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Meter Identification Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMeterIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Meter Identification Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMeterIdentificationClusterClientTickCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMeterIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Meter Identification Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMeterIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Meter Identification Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMeterIdentificationClusterServerInitCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMeterIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Meter Identification Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMeterIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Meter Identification Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMeterIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Meter Identification Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMeterIdentificationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Meter Identification Cluster Callbacks */ + +/** @name Appliance Events and Alert Cluster Callbacks */ +// @{ + +/** @brief Appliance Events and Alert Cluster Alerts Notification + * + * + * + * @param alertsCount Ver.: always + * @param alertStructures Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterAlertsNotificationCallback(uint8_t alertsCount, + uint8_t* alertStructures); +/** @brief Appliance Events and Alert Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Events and Alert Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Events and Alert Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Events and Alert Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Events and Alert Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceEventsAndAlertClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Events and Alert Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Events Notification + * + * + * + * @param eventHeader Ver.: always + * @param eventId Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterEventsNotificationCallback(uint8_t eventHeader, + uint8_t eventId); +/** @brief Appliance Events and Alert Cluster Get Alerts + * + * + * + */ +bool emberAfApplianceEventsAndAlertClusterGetAlertsCallback(void); +/** @brief Appliance Events and Alert Cluster Get Alerts Response + * + * + * + * @param alertsCount Ver.: always + * @param alertStructures Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterGetAlertsResponseCallback(uint8_t alertsCount, + uint8_t* alertStructures); +/** @brief Appliance Events and Alert Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Events and Alert Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Events and Alert Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Events and Alert Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Events and Alert Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceEventsAndAlertClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Events and Alert Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerTickCallback(uint8_t endpoint); + +/** @} END Appliance Events and Alert Cluster Callbacks */ + +/** @name Appliance Statistics Cluster Callbacks */ +// @{ + +/** @brief Appliance Statistics Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceStatisticsClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Statistics Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceStatisticsClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Statistics Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceStatisticsClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceStatisticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Statistics Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceStatisticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Statistics Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceStatisticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Statistics Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceStatisticsClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Log Notification + * + * + * + * @param timeStamp Ver.: always + * @param logId Ver.: always + * @param logLength Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogNotificationCallback(uint32_t timeStamp, + uint32_t logId, + uint32_t logLength, + uint8_t* logPayload); +/** @brief Appliance Statistics Cluster Log Queue Request + * + * + * + */ +bool emberAfApplianceStatisticsClusterLogQueueRequestCallback(void); +/** @brief Appliance Statistics Cluster Log Queue Response + * + * + * + * @param logQueueSize Ver.: always + * @param logIds Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogQueueResponseCallback(uint8_t logQueueSize, + uint8_t* logIds); +/** @brief Appliance Statistics Cluster Log Request + * + * + * + * @param logId Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogRequestCallback(uint32_t logId); +/** @brief Appliance Statistics Cluster Log Response + * + * + * + * @param timeStamp Ver.: always + * @param logId Ver.: always + * @param logLength Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogResponseCallback(uint32_t timeStamp, + uint32_t logId, + uint32_t logLength, + uint8_t* logPayload); +/** @brief Appliance Statistics Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceStatisticsClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Appliance Statistics Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceStatisticsClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Appliance Statistics Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceStatisticsClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceStatisticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Statistics Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceStatisticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Appliance Statistics Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceStatisticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Appliance Statistics Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceStatisticsClusterServerTickCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Statistics Available + * + * + * + * @param logQueueSize Ver.: always + * @param logIds Ver.: always + */ +bool emberAfApplianceStatisticsClusterStatisticsAvailableCallback(uint8_t logQueueSize, + uint8_t* logIds); + +/** @} END Appliance Statistics Cluster Callbacks */ + +/** @name Electrical Measurement Cluster Callbacks */ +// @{ + +/** @brief Electrical Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfElectricalMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Electrical Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfElectricalMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Electrical Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfElectricalMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfElectricalMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Electrical Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfElectricalMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Electrical Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfElectricalMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Electrical Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfElectricalMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Get Measurement Profile Command + * + * + * + * @param attributeId Ver.: always + * @param startTime Ver.: always + * @param numberOfIntervals Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetMeasurementProfileCommandCallback(uint16_t attributeId, + uint32_t startTime, + uint8_t numberOfIntervals); +/** @brief Electrical Measurement Cluster Get Measurement Profile Response Command + * + * + * + * @param startTime Ver.: always + * @param status Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param numberOfIntervalsDelivered Ver.: always + * @param attributeId Ver.: always + * @param intervals Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(uint32_t startTime, + uint8_t status, + uint8_t profileIntervalPeriod, + uint8_t numberOfIntervalsDelivered, + uint16_t attributeId, + uint8_t* intervals); +/** @brief Electrical Measurement Cluster Get Profile Info Command + * + * + * + */ +bool emberAfElectricalMeasurementClusterGetProfileInfoCommandCallback(void); +/** @brief Electrical Measurement Cluster Get Profile Info Response Command + * + * + * + * @param profileCount Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param maxNumberOfIntervals Ver.: always + * @param listOfAttributes Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(uint8_t profileCount, + uint8_t profileIntervalPeriod, + uint8_t maxNumberOfIntervals, + uint8_t* listOfAttributes); +/** @brief Electrical Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfElectricalMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Electrical Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfElectricalMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Electrical Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfElectricalMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfElectricalMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Electrical Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfElectricalMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Electrical Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfElectricalMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Electrical Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfElectricalMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Electrical Measurement Cluster Callbacks */ + +/** @name Diagnostics Cluster Callbacks */ +// @{ + +/** @brief Diagnostics Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDiagnosticsClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Diagnostics Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDiagnosticsClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Diagnostics Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDiagnosticsClusterClientInitCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDiagnosticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Diagnostics Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDiagnosticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Diagnostics Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDiagnosticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Diagnostics Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDiagnosticsClusterClientTickCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDiagnosticsClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Diagnostics Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDiagnosticsClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Diagnostics Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDiagnosticsClusterServerInitCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Diagnostics Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Diagnostics Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDiagnosticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Diagnostics Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDiagnosticsClusterServerTickCallback(uint8_t endpoint); + +/** @} END Diagnostics Cluster Callbacks */ + +/** @name ZLL Commissioning Cluster Callbacks */ +// @{ + +/** @brief ZLL Commissioning Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfZllCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief ZLL Commissioning Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfZllCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief ZLL Commissioning Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfZllCommissioningClusterClientInitCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfZllCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ZLL Commissioning Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfZllCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief ZLL Commissioning Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfZllCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief ZLL Commissioning Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfZllCommissioningClusterClientTickCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Device Information Request + * + * + * + * @param transaction Ver.: always + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterDeviceInformationRequestCallback(uint32_t transaction, + uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Device Information Response + * + * + * + * @param transaction Ver.: always + * @param numberOfSubDevices Ver.: always + * @param startIndex Ver.: always + * @param deviceInformationRecordCount Ver.: always + * @param deviceInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterDeviceInformationResponseCallback(uint32_t transaction, + uint8_t numberOfSubDevices, + uint8_t startIndex, + uint8_t deviceInformationRecordCount, + uint8_t* deviceInformationRecordList); +/** @brief ZLL Commissioning Cluster Endpoint Information + * + * + * + * @param ieeeAddress Ver.: always + * @param networkAddress Ver.: always + * @param endpointId Ver.: always + * @param profileId Ver.: always + * @param deviceId Ver.: always + * @param version Ver.: always + */ +bool emberAfZllCommissioningClusterEndpointInformationCallback(uint8_t* ieeeAddress, + uint16_t networkAddress, + uint8_t endpointId, + uint16_t profileId, + uint16_t deviceId, + uint8_t version); +/** @brief ZLL Commissioning Cluster Get Endpoint List Request + * + * + * + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterGetEndpointListRequestCallback(uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Get Endpoint List Response + * + * + * + * @param total Ver.: always + * @param startIndex Ver.: always + * @param count Ver.: always + * @param endpointInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterGetEndpointListResponseCallback(uint8_t total, + uint8_t startIndex, + uint8_t count, + uint8_t* endpointInformationRecordList); +/** @brief ZLL Commissioning Cluster Get Group Identifiers Request + * + * + * + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterGetGroupIdentifiersRequestCallback(uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Get Group Identifiers Response + * + * + * + * @param total Ver.: always + * @param startIndex Ver.: always + * @param count Ver.: always + * @param groupInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterGetGroupIdentifiersResponseCallback(uint8_t total, + uint8_t startIndex, + uint8_t count, + uint8_t* groupInformationRecordList); +/** @brief ZLL Commissioning Cluster Identify Request + * + * + * + * @param transaction Ver.: always + * @param identifyDuration Ver.: always + */ +bool emberAfZllCommissioningClusterIdentifyRequestCallback(uint32_t transaction, + uint16_t identifyDuration); +/** @brief ZLL Commissioning Cluster Network Join End Device Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceRequestCallback(uint32_t transaction, + uint8_t* extendedPanId, + uint8_t keyIndex, + uint8_t* encryptedNetworkKey, + uint8_t networkUpdateId, + uint8_t logicalChannel, + uint16_t panId, + uint16_t networkAddress, + uint16_t groupIdentifiersBegin, + uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, + uint16_t freeNetworkAddressRangeEnd, + uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); +/** @brief ZLL Commissioning Cluster Network Join End Device Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceResponseCallback(uint32_t transaction, + uint8_t status); +/** @brief ZLL Commissioning Cluster Network Join Router Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinRouterRequestCallback(uint32_t transaction, + uint8_t* extendedPanId, + uint8_t keyIndex, + uint8_t* encryptedNetworkKey, + uint8_t networkUpdateId, + uint8_t logicalChannel, + uint16_t panId, + uint16_t networkAddress, + uint16_t groupIdentifiersBegin, + uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, + uint16_t freeNetworkAddressRangeEnd, + uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); +/** @brief ZLL Commissioning Cluster Network Join Router Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinRouterResponseCallback(uint32_t transaction, + uint8_t status); +/** @brief ZLL Commissioning Cluster Network Start Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + * @param initiatorIeeeAddress Ver.: always + * @param initiatorNetworkAddress Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkStartRequestCallback(uint32_t transaction, + uint8_t* extendedPanId, + uint8_t keyIndex, + uint8_t* encryptedNetworkKey, + uint8_t logicalChannel, + uint16_t panId, + uint16_t networkAddress, + uint16_t groupIdentifiersBegin, + uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, + uint16_t freeNetworkAddressRangeEnd, + uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd, + uint8_t* initiatorIeeeAddress, + uint16_t initiatorNetworkAddress); +/** @brief ZLL Commissioning Cluster Network Start Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkStartResponseCallback(uint32_t transaction, + uint8_t status, + uint8_t* extendedPanId, + uint8_t networkUpdateId, + uint8_t logicalChannel, + uint16_t panId); +/** @brief ZLL Commissioning Cluster Network Update Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkUpdateRequestCallback(uint32_t transaction, + uint8_t* extendedPanId, + uint8_t networkUpdateId, + uint8_t logicalChannel, + uint16_t panId, + uint16_t networkAddress); +/** @brief ZLL Commissioning Cluster Reset To Factory New Request + * + * + * + * @param transaction Ver.: always + */ +bool emberAfZllCommissioningClusterResetToFactoryNewRequestCallback(uint32_t transaction); +/** @brief ZLL Commissioning Cluster Scan Request + * + * + * + * @param transaction Ver.: always + * @param zigbeeInformation Ver.: always + * @param zllInformation Ver.: always + */ +bool emberAfZllCommissioningClusterScanRequestCallback(uint32_t transaction, + uint8_t zigbeeInformation, + uint8_t zllInformation); +/** @brief ZLL Commissioning Cluster Scan Response + * + * + * + * @param transaction Ver.: always + * @param rssiCorrection Ver.: always + * @param zigbeeInformation Ver.: always + * @param zllInformation Ver.: always + * @param keyBitmask Ver.: always + * @param responseId Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param numberOfSubDevices Ver.: always + * @param totalGroupIds Ver.: always + * @param endpointId Ver.: always + * @param profileId Ver.: always + * @param deviceId Ver.: always + * @param version Ver.: always + * @param groupIdCount Ver.: always + */ +bool emberAfZllCommissioningClusterScanResponseCallback(uint32_t transaction, + uint8_t rssiCorrection, + uint8_t zigbeeInformation, + uint8_t zllInformation, + uint16_t keyBitmask, + uint32_t responseId, + uint8_t* extendedPanId, + uint8_t networkUpdateId, + uint8_t logicalChannel, + uint16_t panId, + uint16_t networkAddress, + uint8_t numberOfSubDevices, + uint8_t totalGroupIds, + uint8_t endpointId, + uint16_t profileId, + uint16_t deviceId, + uint8_t version, + uint8_t groupIdCount); +/** @brief ZLL Commissioning Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfZllCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief ZLL Commissioning Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfZllCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief ZLL Commissioning Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfZllCommissioningClusterServerInitCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfZllCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ZLL Commissioning Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfZllCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief ZLL Commissioning Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfZllCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief ZLL Commissioning Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfZllCommissioningClusterServerTickCallback(uint8_t endpoint); + +/** @} END ZLL Commissioning Cluster Callbacks */ + +/** @name Sample Mfg Specific Cluster Cluster Callbacks */ +// @{ + +/** @brief Sample Mfg Specific Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sample Mfg Specific Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientTickCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Command One + * + * + * + * @param argOne Ver.: always + */ +bool emberAfSampleMfgSpecificClusterCommandOneCallback(uint8_t argOne); +/** @brief Sample Mfg Specific Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sample Mfg Specific Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sample Mfg Specific Cluster Cluster Callbacks */ + +/** @name Sample Mfg Specific Cluster 2 Cluster Callbacks */ +// @{ + +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificCluster2ClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientTickCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Command Two + * + * + * + * @param argOne Ver.: always + */ +bool emberAfSampleMfgSpecificCluster2CommandTwoCallback(uint8_t argOne); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificCluster2ServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerTickCallback(uint8_t endpoint); + +/** @} END Sample Mfg Specific Cluster 2 Cluster Callbacks */ + +/** @name Configuration Cluster Cluster Callbacks */ +// @{ + +/** @brief Configuration Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Configuration Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Configuration Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaConfigurationClusterClientInitCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Configuration Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Configuration Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Configuration Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaConfigurationClusterClientTickCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Lock Tokens + * + * + * + */ +bool emberAfOtaConfigurationClusterLockTokensCallback(void); +/** @brief Configuration Cluster Cluster Read Tokens + * + * + * + * @param token Ver.: always + */ +bool emberAfOtaConfigurationClusterReadTokensCallback(uint16_t token); +/** @brief Configuration Cluster Cluster Return Token + * + * + * + * @param token Ver.: always + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterReturnTokenCallback(uint16_t token, + uint8_t* data); +/** @brief Configuration Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Configuration Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief Configuration Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaConfigurationClusterServerInitCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Configuration Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief Configuration Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief Configuration Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaConfigurationClusterServerTickCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Set Token + * + * + * + * @param token Ver.: always + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterSetTokenCallback(uint16_t token, + uint8_t* data); +/** @brief Configuration Cluster Cluster Unlock Tokens + * + * + * + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterUnlockTokensCallback(uint8_t* data); + +/** @} END Configuration Cluster Cluster Callbacks */ + +/** @name MFGLIB Cluster Cluster Callbacks */ +// @{ + +/** @brief MFGLIB Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMfglibClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief MFGLIB Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMfglibClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief MFGLIB Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMfglibClusterClientInitCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMfglibClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MFGLIB Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMfglibClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief MFGLIB Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMfglibClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief MFGLIB Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMfglibClusterClientTickCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Rx Mode + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterRxModeCallback(uint8_t channel, + int8_t power, + uint16_t time); +/** @brief MFGLIB Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMfglibClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief MFGLIB Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMfglibClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief MFGLIB Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMfglibClusterServerInitCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMfglibClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MFGLIB Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMfglibClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief MFGLIB Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMfglibClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief MFGLIB Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMfglibClusterServerTickCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Stream + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterStreamCallback(uint8_t channel, + int8_t power, + uint16_t time); +/** @brief MFGLIB Cluster Cluster Tone + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterToneCallback(uint8_t channel, + int8_t power, + uint16_t time); + +/** @} END MFGLIB Cluster Cluster Callbacks */ + +/** @name SL Works With All Hubs Cluster Callbacks */ +// @{ + +/** @brief SL Works With All Hubs Cluster Aps Ack Enablement Query Response + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterApsAckEnablementQueryResponseCallback(uint8_t numberExemptClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Aps Ack Requirement Query + * + * + * + */ +bool emberAfSlWwahClusterApsAckRequirementQueryCallback(void); +/** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query + * + * + * + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryCallback(uint16_t clusterId); +/** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query Response + * + * + * + * @param clusterId Ver.: always + * @param apsLinkKeyAuthStatus Ver.: always + */ +bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryResponseCallback(uint16_t clusterId, + uint8_t apsLinkKeyAuthStatus); +/** @brief SL Works With All Hubs Cluster Clear Binding Table + * + * + * + */ +bool emberAfSlWwahClusterClearBindingTableCallback(void); +/** @brief SL Works With All Hubs Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSlWwahClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief SL Works With All Hubs Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSlWwahClusterClientDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief SL Works With All Hubs Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSlWwahClusterClientInitCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSlWwahClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief SL Works With All Hubs Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSlWwahClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief SL Works With All Hubs Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSlWwahClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief SL Works With All Hubs Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSlWwahClusterClientTickCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Debug Report Query + * + * + * + * @param debugReportId Ver.: always + */ +bool emberAfSlWwahClusterDebugReportQueryCallback(uint8_t debugReportId); +/** @brief SL Works With All Hubs Cluster Debug Report Query Response + * + * + * + * @param debugReportId Ver.: always + * @param debugReportData Ver.: always + */ +bool emberAfSlWwahClusterDebugReportQueryResponseCallback(uint8_t debugReportId, + uint8_t* debugReportData); +/** @brief SL Works With All Hubs Cluster Disable Aps Link Key Authorization + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterDisableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Disable Configuration Mode + * + * + * + */ +bool emberAfSlWwahClusterDisableConfigurationModeCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Mgmt Leave Without Rejoin + * + * + * + */ +bool emberAfSlWwahClusterDisableMgmtLeaveWithoutRejoinCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Ota Downgrades + * + * + * + */ +bool emberAfSlWwahClusterDisableOtaDowngradesCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Periodic Router Check Ins + * + * + * + */ +bool emberAfSlWwahClusterDisablePeriodicRouterCheckInsCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Touchlink Interpan Message Support + * + * + * + */ +bool emberAfSlWwahClusterDisableTouchlinkInterpanMessageSupportCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah App Event Retry Algorithm + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahAppEventRetryAlgorithmCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Bad Parent Recovery + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahBadParentRecoveryCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Parent Classification + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahParentClassificationCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Rejoin Algorithm + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahRejoinAlgorithmCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Aps Link Key Authorization + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterEnableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Enable Configuration Mode + * + * + * + */ +bool emberAfSlWwahClusterEnableConfigurationModeCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Periodic Router Check Ins + * + * + * + * @param checkInInterval Ver.: always + */ +bool emberAfSlWwahClusterEnablePeriodicRouterCheckInsCallback(uint16_t checkInInterval); +/** @brief SL Works With All Hubs Cluster Enable Tc Security On Ntwk Key Rotation + * + * + * + */ +bool emberAfSlWwahClusterEnableTcSecurityOnNtwkKeyRotationCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah App Event Retry Algorithm + * + * + * + * @param firstBackoffTimeSeconds Ver.: always + * @param backoffSeqCommonRatio Ver.: always + * @param maxBackoffTimeSeconds Ver.: always + * @param maxRedeliveryAttempts Ver.: always + */ +bool emberAfSlWwahClusterEnableWwahAppEventRetryAlgorithmCallback(uint8_t firstBackoffTimeSeconds, + uint8_t backoffSeqCommonRatio, + uint32_t maxBackoffTimeSeconds, + uint8_t maxRedeliveryAttempts); +/** @brief SL Works With All Hubs Cluster Enable Wwah Bad Parent Recovery + * + * + * + */ +bool emberAfSlWwahClusterEnableWwahBadParentRecoveryCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah Parent Classification + * + * + * + */ +bool emberAfSlWwahClusterEnableWwahParentClassificationCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah Rejoin Algorithm + * + * + * + * @param fastRejoinTimeoutSeconds Ver.: always + * @param durationBetweenRejoinsSeconds Ver.: always + * @param fastRejoinFirstBackoffSeconds Ver.: always + * @param maxBackoffTimeSeconds Ver.: always + * @param maxBackoffIterations Ver.: always + */ +bool emberAfSlWwahClusterEnableWwahRejoinAlgorithmCallback(uint16_t fastRejoinTimeoutSeconds, + uint16_t durationBetweenRejoinsSeconds, + uint16_t fastRejoinFirstBackoffSeconds, + uint16_t maxBackoffTimeSeconds, + uint16_t maxBackoffIterations); +/** @brief SL Works With All Hubs Cluster New Debug Report Notification + * + * + * + * @param debugReportId Ver.: always + * @param debugReportSize Ver.: always + */ +bool emberAfSlWwahClusterNewDebugReportNotificationCallback(uint8_t debugReportId, + uint32_t debugReportSize); +/** @brief SL Works With All Hubs Cluster Power Descriptor Change + * + * + * + * @param currentPowerMode Ver.: always + * @param availablePowerSources Ver.: always + * @param currentPowerSource Ver.: always + * @param currentPowerSourceLevel Ver.: always + */ +bool emberAfSlWwahClusterPowerDescriptorChangeCallback(uint32_t currentPowerMode, + uint32_t availablePowerSources, + uint32_t currentPowerSource, + uint32_t currentPowerSourceLevel); +/** @brief SL Works With All Hubs Cluster Powering Off Notification + * + * + * + * @param powerNotificationReason Ver.: always + * @param manufacturerId Ver.: always + * @param manufacturerReasonLength Ver.: always + * @param manufacturerReason Ver.: always + */ +bool emberAfSlWwahClusterPoweringOffNotificationCallback(uint8_t powerNotificationReason, + uint16_t manufacturerId, + uint8_t manufacturerReasonLength, + uint8_t* manufacturerReason); +/** @brief SL Works With All Hubs Cluster Powering On Notification + * + * + * + * @param powerNotificationReason Ver.: always + * @param manufacturerId Ver.: always + * @param manufacturerReasonLength Ver.: always + * @param manufacturerReason Ver.: always + */ +bool emberAfSlWwahClusterPoweringOnNotificationCallback(uint8_t powerNotificationReason, + uint16_t manufacturerId, + uint8_t manufacturerReasonLength, + uint8_t* manufacturerReason); +/** @brief SL Works With All Hubs Cluster Remove Aps Acks On Unicasts Requirement + * + * + * + */ +bool emberAfSlWwahClusterRemoveApsAcksOnUnicastsRequirementCallback(void); +/** @brief SL Works With All Hubs Cluster Request New Aps Link Key + * + * + * + */ +bool emberAfSlWwahClusterRequestNewApsLinkKeyCallback(void); +/** @brief SL Works With All Hubs Cluster Request Time + * + * + * + */ +bool emberAfSlWwahClusterRequestTimeCallback(void); +/** @brief SL Works With All Hubs Cluster Require Aps Acks On Unicasts + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterRequireApsAcksOnUnicastsCallback(uint8_t numberExemptClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSlWwahClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief SL Works With All Hubs Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSlWwahClusterServerDefaultResponseCallback(uint8_t endpoint, + uint8_t commandId, + EmberAfStatus status); +/** @brief SL Works With All Hubs Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSlWwahClusterServerInitCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSlWwahClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief SL Works With All Hubs Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSlWwahClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame *apsFrame, + uint16_t msgLen, + uint8_t *message, + EmberStatus status); +/** @brief SL Works With All Hubs Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSlWwahClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, + uint8_t *value); +/** @brief SL Works With All Hubs Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSlWwahClusterServerTickCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Set Ias Zone Enrollment Method + * + * + * + * @param enrollmentMode Ver.: always + */ +bool emberAfSlWwahClusterSetIasZoneEnrollmentMethodCallback(uint8_t enrollmentMode); +/** @brief SL Works With All Hubs Cluster Set Mac Poll Failure Wait Time + * + * + * + * @param waitTime Ver.: always + */ +bool emberAfSlWwahClusterSetMacPollFailureWaitTimeCallback(uint8_t waitTime); +/** @brief SL Works With All Hubs Cluster Set Pending Network Update + * + * + * + * @param channel Ver.: always + * @param panId Ver.: always + */ +bool emberAfSlWwahClusterSetPendingNetworkUpdateCallback(uint8_t channel, + uint16_t panId); +/** @brief SL Works With All Hubs Cluster Short Address Change + * + * + * + * @param deviceEui64 Ver.: always + * @param deviceShort Ver.: always + */ +bool emberAfSlWwahClusterShortAddressChangeCallback(uint8_t* deviceEui64, + uint16_t deviceShort); +/** @brief SL Works With All Hubs Cluster Survey Beacons + * + * + * + * @param standardBeacons Ver.: always + */ +bool emberAfSlWwahClusterSurveyBeaconsCallback(uint8_t standardBeacons); +/** @brief SL Works With All Hubs Cluster Survey Beacons Response + * + * + * + * @param numberOfBeacons Ver.: always + * @param beacon Ver.: always + */ +bool emberAfSlWwahClusterSurveyBeaconsResponseCallback(uint8_t numberOfBeacons, + uint8_t* beacon); +/** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query + * + * + * + */ +bool emberAfSlWwahClusterTrustCenterForClusterServerQueryCallback(void); +/** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query Response + * + * + * + * @param numberOfClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterTrustCenterForClusterServerQueryResponseCallback(uint8_t numberOfClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server + * + * + * + * @param numberOfClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterUseTrustCenterForClusterServerCallback(uint8_t numberOfClusters, + uint8_t* clusterId); +/** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server Response + * + * + * + * @param status Ver.: always + * @param clusterStatusLength Ver.: always + * @param clusterStatus Ver.: always + */ +bool emberAfSlWwahClusterUseTrustCenterForClusterServerResponseCallback(uint8_t status, + uint8_t clusterStatusLength, + uint8_t* clusterStatus); + +/** @} END SL Works With All Hubs Cluster Callbacks */ + + +/** @name Update TC Link Key Plugin Callbacks */ +// @{ + +/** @brief Status + * + * This callback is fired when the Update Link Key exchange process is updated + * with a status from the stack. Implementations will know that the Update TC + * Link Key plugin has completed its link key request when the keyStatus + * parameter is EMBER_VERIFY_LINK_KEY_SUCCESS. + * + * @param keyStatus An ::EmberKeyStatus value describing the success or failure + * of the key exchange process. Ver.: always + */ +void emberAfPluginUpdateTcLinkKeyStatusCallback(EmberKeyStatus keyStatus); +/** @} END Update TC Link Key Plugin Callbacks */ + + +/** @name Network Steering Plugin Callbacks */ +// @{ + +/** @brief Complete + * + * This callback is fired when the Network Steering plugin is complete. + * + * @param status On success this will be set to EMBER_SUCCESS to indicate a + * network was joined successfully. On failure this will be the status code of + * the last join or scan attempt. Ver.: always + * @param totalBeacons The total number of 802.15.4 beacons that were heard, + * including beacons from different devices with the same PAN ID. Ver.: always + * @param joinAttempts The number of join attempts that were made to get onto + * an open Zigbee network. Ver.: always + * @param finalState The finishing state of the network steering process. From + * this, one is able to tell on which channel mask and with which key the + * process was complete. Ver.: always + */ +void emberAfPluginNetworkSteeringCompleteCallback(EmberStatus status, + uint8_t totalBeacons, + uint8_t joinAttempts, + uint8_t finalState); +/** @brief Get Power For Radio Channel + * + * This callback is fired when the Network Steering plugin needs to set the + * power level. The application has the ability to change the max power level + * used for this particular channel. + * + * @param channel The channel that the plugin is inquiring about the power + * level. Ver.: always + */ +int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t channel); +/** @brief Get Distributed Key + * + * This callback is fired when the Network Steering plugin needs to set the distributed + * key. The application set the distributed key from Zigbee Alliance thru this callback + * or the network steering will use the default test key. + * + * @param pointer to the distributed key struct + * @return true if the key is loaded successfully, otherwise false. + * level. Ver.: always + */ +bool emberAfPluginNetworkSteeringGetDistributedKeyCallback(EmberKeyData * key); +/** @brief Get Node Type + * + * This callback allows the application to set the node type that the network + * steering process will use in joining a network. + * + * @param state The current ::EmberAfPluginNetworkSteeringJoiningState. + * + * @return An ::EmberNodeType value that the network steering process will + * try to join a network as. + */ +EmberNodeType emberAfPluginNetworkSteeringGetNodeTypeCallback(EmberAfPluginNetworkSteeringJoiningState state); +/** @} END Network Steering Plugin Callbacks */ + + +/** @name HAL Library Plugin Callbacks */ +// @{ + +/** + * @brief Called whenever the radio is powered on. + */ +void halRadioPowerUpHandler(void); +/** + * @brief Called whenever the radio is powered off. + */ +void halRadioPowerDownHandler(void); +/** + * @brief Called whenever the microcontroller enters/exits a idle/sleep mode + * + * @param enter True if entering idle/sleep, False if exiting + * @param sleepMode Idle/sleep mode + */ +void halSleepCallback(boolean enter, SleepModes sleepMode); +/** @} END HAL Library Plugin Callbacks */ + + +/** @} END addtogroup */ +#endif // SILABS_EMBER_AF_CALLBACK_PROTOTYPES diff --git a/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h b/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h new file mode 100644 index 00000000000000..5b2509a6c2191e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h @@ -0,0 +1,14295 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_CLUSTER_CLIENT_API +#define SILABS_CLUSTER_CLIENT_API + + +// This is generated client API + + + +/** + * @addtogroup command Application Framework command interface Reference + * This document describes the ZCL command interface used by the Ember + * Application Framework for filling ZCL command buffers. + * @{ + */ +/** @name Global Commands */ +// @{ +/** @brief Command description for ReadAttributes + * + * Command: ReadAttributes + * @param clusterId EmberAfClusterId + * @param attributeIds uint8_t* + * @param attributeIdsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReadAttributes(clusterId, \ + attributeIds, \ + attributeIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_COMMAND_ID, \ + "b", \ + attributeIds, \ + attributeIdsLen); + + +/** @brief Command description for ReadAttributes + * + * Command: ReadAttributes + * @param clusterId EmberAfClusterId + * @param attributeIds uint8_t* + * @param attributeIdsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReadAttributes(clusterId, \ + attributeIds, \ + attributeIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_COMMAND_ID, \ + "b", \ + attributeIds, \ + attributeIdsLen); + + +/** @brief Command description for ReadAttributesResponse + * + * Command: ReadAttributesResponse + * @param clusterId EmberAfClusterId + * @param readAttributeStatusRecords uint8_t* + * @param readAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReadAttributesResponse(clusterId, \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "b", \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen); + + +/** @brief Command description for ReadAttributesResponse + * + * Command: ReadAttributesResponse + * @param clusterId EmberAfClusterId + * @param readAttributeStatusRecords uint8_t* + * @param readAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReadAttributesResponse(clusterId, \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "b", \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen); + + +/** @brief Command description for WriteAttributes + * + * Command: WriteAttributes + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributes(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for WriteAttributes + * + * Command: WriteAttributes + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributes(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesUndivided + * + * Command: WriteAttributesUndivided + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributesUndivided(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesUndivided + * + * Command: WriteAttributesUndivided + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributesUndivided(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesResponse + * + * Command: WriteAttributesResponse + * @param clusterId EmberAfClusterId + * @param writeAttributeStatusRecords uint8_t* + * @param writeAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributesResponse(clusterId, \ + writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "b", \ + writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen); + + +/** @brief Command description for WriteAttributesResponse + * + * Command: WriteAttributesResponse + * @param clusterId EmberAfClusterId + * @param writeAttributeStatusRecords uint8_t* + * @param writeAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributesResponse(clusterId, \ + writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "b", \ + writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen); + + +/** @brief Command description for WriteAttributesNoResponse + * + * Command: WriteAttributesNoResponse + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributesNoResponse(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesNoResponse + * + * Command: WriteAttributesNoResponse + * @param clusterId EmberAfClusterId + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributesNoResponse(clusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, \ + "b", \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief Command description for ConfigureReporting + * + * Command: ConfigureReporting + * @param clusterId EmberAfClusterId + * @param configureReportingRecords uint8_t* + * @param configureReportingRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientConfigureReporting(clusterId, \ + configureReportingRecords, \ + configureReportingRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_CONFIGURE_REPORTING_COMMAND_ID, \ + "b", \ + configureReportingRecords, \ + configureReportingRecordsLen); + + +/** @brief Command description for ConfigureReporting + * + * Command: ConfigureReporting + * @param clusterId EmberAfClusterId + * @param configureReportingRecords uint8_t* + * @param configureReportingRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerConfigureReporting(clusterId, \ + configureReportingRecords, \ + configureReportingRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_CONFIGURE_REPORTING_COMMAND_ID, \ + "b", \ + configureReportingRecords, \ + configureReportingRecordsLen); + + +/** @brief Command description for ConfigureReportingResponse + * + * Command: ConfigureReportingResponse + * @param clusterId EmberAfClusterId + * @param configureReportingStatusRecords uint8_t* + * @param configureReportingStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientConfigureReportingResponse(clusterId, \ + configureReportingStatusRecords, \ + configureReportingStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, \ + "b", \ + configureReportingStatusRecords, \ + configureReportingStatusRecordsLen); + + +/** @brief Command description for ConfigureReportingResponse + * + * Command: ConfigureReportingResponse + * @param clusterId EmberAfClusterId + * @param configureReportingStatusRecords uint8_t* + * @param configureReportingStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerConfigureReportingResponse(clusterId, \ + configureReportingStatusRecords, \ + configureReportingStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, \ + "b", \ + configureReportingStatusRecords, \ + configureReportingStatusRecordsLen); + + +/** @brief Command description for ReadReportingConfiguration + * + * Command: ReadReportingConfiguration + * @param clusterId EmberAfClusterId + * @param readReportingConfigurationAttributeRecords uint8_t* + * @param readReportingConfigurationAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReadReportingConfiguration(clusterId, \ + readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, \ + "b", \ + readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen); + + +/** @brief Command description for ReadReportingConfiguration + * + * Command: ReadReportingConfiguration + * @param clusterId EmberAfClusterId + * @param readReportingConfigurationAttributeRecords uint8_t* + * @param readReportingConfigurationAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReadReportingConfiguration(clusterId, \ + readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, \ + "b", \ + readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen); + + +/** @brief Command description for ReadReportingConfigurationResponse + * + * Command: ReadReportingConfigurationResponse + * @param clusterId EmberAfClusterId + * @param readReportingConfigurationRecords uint8_t* + * @param readReportingConfigurationRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReadReportingConfigurationResponse(clusterId, \ + readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, \ + "b", \ + readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen); + + +/** @brief Command description for ReadReportingConfigurationResponse + * + * Command: ReadReportingConfigurationResponse + * @param clusterId EmberAfClusterId + * @param readReportingConfigurationRecords uint8_t* + * @param readReportingConfigurationRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReadReportingConfigurationResponse(clusterId, \ + readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, \ + "b", \ + readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen); + + +/** @brief Command description for ReportAttributes + * + * Command: ReportAttributes + * @param clusterId EmberAfClusterId + * @param reportAttributeRecords uint8_t* + * @param reportAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReportAttributes(clusterId, \ + reportAttributeRecords, \ + reportAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_REPORT_ATTRIBUTES_COMMAND_ID, \ + "b", \ + reportAttributeRecords, \ + reportAttributeRecordsLen); + + +/** @brief Command description for ReportAttributes + * + * Command: ReportAttributes + * @param clusterId EmberAfClusterId + * @param reportAttributeRecords uint8_t* + * @param reportAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReportAttributes(clusterId, \ + reportAttributeRecords, \ + reportAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_REPORT_ATTRIBUTES_COMMAND_ID, \ + "b", \ + reportAttributeRecords, \ + reportAttributeRecordsLen); + + +/** @brief Command description for DefaultResponse + * + * Command: DefaultResponse + * @param clusterId EmberAfClusterId + * @param commandId uint8_t + * @param status uint8_t + */ +#define emberAfFillCommandGlobalServerToClientDefaultResponse(clusterId, \ + commandId, \ + status) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DEFAULT_RESPONSE_COMMAND_ID, \ + "uu", \ + commandId, \ + status); + + +/** @brief Command description for DefaultResponse + * + * Command: DefaultResponse + * @param clusterId EmberAfClusterId + * @param commandId uint8_t + * @param status uint8_t + */ +#define emberAfFillCommandGlobalClientToServerDefaultResponse(clusterId, \ + commandId, \ + status) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DEFAULT_RESPONSE_COMMAND_ID, \ + "uu", \ + commandId, \ + status); + + +/** @brief Command description for DiscoverAttributes + * + * Command: DiscoverAttributes + * @param clusterId EmberAfClusterId + * @param startId uint16_t + * @param maxAttributeIds uint8_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverAttributes(clusterId, \ + startId, \ + maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, \ + "vu", \ + startId, \ + maxAttributeIds); + + +/** @brief Command description for DiscoverAttributes + * + * Command: DiscoverAttributes + * @param clusterId EmberAfClusterId + * @param startId uint16_t + * @param maxAttributeIds uint8_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverAttributes(clusterId, \ + startId, \ + maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, \ + "vu", \ + startId, \ + maxAttributeIds); + + +/** @brief Command description for DiscoverAttributesResponse + * + * Command: DiscoverAttributesResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param discoverAttributesInfoRecords uint8_t* + * @param discoverAttributesInfoRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesResponse(clusterId, \ + discoveryComplete, \ + discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen); + + +/** @brief Command description for DiscoverAttributesResponse + * + * Command: DiscoverAttributesResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param discoverAttributesInfoRecords uint8_t* + * @param discoverAttributesInfoRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesResponse(clusterId, \ + discoveryComplete, \ + discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen); + + +/** @brief Command description for ReadAttributesStructured + * + * Command: ReadAttributesStructured + * @param clusterId EmberAfClusterId + * @param readStructuredAttributeRecords uint8_t* + * @param readStructuredAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientReadAttributesStructured(clusterId, \ + readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ + "b", \ + readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen); + + +/** @brief Command description for ReadAttributesStructured + * + * Command: ReadAttributesStructured + * @param clusterId EmberAfClusterId + * @param readStructuredAttributeRecords uint8_t* + * @param readStructuredAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerReadAttributesStructured(clusterId, \ + readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ + "b", \ + readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesStructured + * + * Command: WriteAttributesStructured + * @param clusterId EmberAfClusterId + * @param writeStructuredAttributeRecords uint8_t* + * @param writeStructuredAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributesStructured(clusterId, \ + writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ + "b", \ + writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesStructured + * + * Command: WriteAttributesStructured + * @param clusterId EmberAfClusterId + * @param writeStructuredAttributeRecords uint8_t* + * @param writeStructuredAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributesStructured(clusterId, \ + writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ + "b", \ + writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen); + + +/** @brief Command description for WriteAttributesStructuredResponse + * + * Command: WriteAttributesStructuredResponse + * @param clusterId EmberAfClusterId + * @param writeStructuredAttributeStatusRecords uint8_t* + * @param writeStructuredAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientWriteAttributesStructuredResponse(clusterId, \ + writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, \ + "b", \ + writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen); + + +/** @brief Command description for WriteAttributesStructuredResponse + * + * Command: WriteAttributesStructuredResponse + * @param clusterId EmberAfClusterId + * @param writeStructuredAttributeStatusRecords uint8_t* + * @param writeStructuredAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerWriteAttributesStructuredResponse(clusterId, \ + writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, \ + "b", \ + writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen); + + +/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or manufacturer specific commands. + * + * Command: DiscoverCommandsReceived + * @param clusterId EmberAfClusterId + * @param startCommandId uint8_t + * @param maxCommandIds uint8_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceived(clusterId, \ + startCommandId, \ + maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, \ + "uu", \ + startCommandId, \ + maxCommandIds); + + +/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or manufacturer specific commands. + * + * Command: DiscoverCommandsReceived + * @param clusterId EmberAfClusterId + * @param startCommandId uint8_t + * @param maxCommandIds uint8_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceived(clusterId, \ + startCommandId, \ + maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, \ + "uu", \ + startCommandId, \ + maxCommandIds); + + +/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used to discover which commands a particular cluster can process. + * + * Command: DiscoverCommandsReceivedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param commandIds uint8_t* + * @param commandIdsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceivedResponse(clusterId, \ + discoveryComplete, \ + commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + commandIds, \ + commandIdsLen); + + +/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used to discover which commands a particular cluster can process. + * + * Command: DiscoverCommandsReceivedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param commandIds uint8_t* + * @param commandIdsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceivedResponse(clusterId, \ + discoveryComplete, \ + commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + commandIds, \ + commandIdsLen); + + +/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or manufacturer specific commands. + * + * Command: DiscoverCommandsGenerated + * @param clusterId EmberAfClusterId + * @param startCommandId uint8_t + * @param maxCommandIds uint8_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGenerated(clusterId, \ + startCommandId, \ + maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, \ + "uu", \ + startCommandId, \ + maxCommandIds); + + +/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or manufacturer specific commands. + * + * Command: DiscoverCommandsGenerated + * @param clusterId EmberAfClusterId + * @param startCommandId uint8_t + * @param maxCommandIds uint8_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGenerated(clusterId, \ + startCommandId, \ + maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, \ + "uu", \ + startCommandId, \ + maxCommandIds); + + +/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to discover which commands a particular cluster supports. + * + * Command: DiscoverCommandsGeneratedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param commandIds uint8_t* + * @param commandIdsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGeneratedResponse(clusterId, \ + discoveryComplete, \ + commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + commandIds, \ + commandIdsLen); + + +/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to discover which commands a particular cluster supports. + * + * Command: DiscoverCommandsGeneratedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param commandIds uint8_t* + * @param commandIdsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGeneratedResponse(clusterId, \ + discoveryComplete, \ + commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + commandIds, \ + commandIdsLen); + + +/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute is readable, writeable or reportable. + * + * Command: DiscoverAttributesExtended + * @param clusterId EmberAfClusterId + * @param startId uint16_t + * @param maxAttributeIds uint8_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtended(clusterId, \ + startId, \ + maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, \ + "vu", \ + startId, \ + maxAttributeIds); + + +/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute is readable, writeable or reportable. + * + * Command: DiscoverAttributesExtended + * @param clusterId EmberAfClusterId + * @param startId uint16_t + * @param maxAttributeIds uint8_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtended(clusterId, \ + startId, \ + maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, \ + "vu", \ + startId, \ + maxAttributeIds); + + +/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are readable, writable or reportable. + * + * Command: DiscoverAttributesExtendedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param extendedDiscoverAttributesInfoRecords uint8_t* + * @param extendedDiscoverAttributesInfoRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtendedResponse(clusterId, \ + discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, \ + extendedDiscoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, \ + extendedDiscoverAttributesInfoRecordsLen); + + +/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are readable, writable or reportable. + * + * Command: DiscoverAttributesExtendedResponse + * @param clusterId EmberAfClusterId + * @param discoveryComplete uint8_t + * @param extendedDiscoverAttributesInfoRecords uint8_t* + * @param extendedDiscoverAttributesInfoRecordsLen uint16_t + */ +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtendedResponse(clusterId, \ + discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, \ + extendedDiscoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, \ + extendedDiscoverAttributesInfoRecordsLen); + + +/** @} END Global Commands */ + + + +/** @name Basic Commands */ +// @{ +/** @brief Command that resets all attribute values to factory default. + * + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. + * Command: ResetToFactoryDefaults + */ +#define emberAfFillCommandBasicClusterResetToFactoryDefaults() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BASIC_CLUSTER_ID, \ + ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID, \ + ""); + + +/** @brief This command gets locales supported. + * + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. + * Command: GetLocalesSupported + * @param startLocale uint8_t* + * @param maxLocalesRequested uint8_t + */ +#define emberAfFillCommandBasicClusterGetLocalesSupported(startLocale, \ + maxLocalesRequested) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BASIC_CLUSTER_ID, \ + ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID, \ + "su", \ + startLocale, \ + maxLocalesRequested); + + +/** @brief The locales supported response command is sent in response to a get locales supported command, and is used to discover which locales the device supports. + * + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. + * Command: GetLocalesSupportedResponse + * @param discoveryComplete uint8_t + * @param localeSupported uint8_t* + * @param localeSupportedLen uint16_t + */ +#define emberAfFillCommandBasicClusterGetLocalesSupportedResponse(discoveryComplete, \ + localeSupported, \ + localeSupportedLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_BASIC_CLUSTER_ID, \ + ZCL_GET_LOCALES_SUPPORTED_RESPONSE_COMMAND_ID, \ + "ub", \ + discoveryComplete, \ + localeSupported, \ + localeSupportedLen); + + +/** @} END Basic Commands */ + + +/** @name Power Configuration Commands */ +// @{ +/** @} END Power Configuration Commands */ + + +/** @name Device Temperature Configuration Commands */ +// @{ +/** @} END Device Temperature Configuration Commands */ + + +/** @name Identify Commands */ +// @{ +/** @brief Command description for Identify + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: Identify + * @param identifyTime uint16_t + */ +#define emberAfFillCommandIdentifyClusterIdentify(identifyTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_COMMAND_ID, \ + "v", \ + identifyTime); + + +/** @brief Command description for IdentifyQuery + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: IdentifyQuery + */ +#define emberAfFillCommandIdentifyClusterIdentifyQuery() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_QUERY_COMMAND_ID, \ + ""); + + +/** @brief Invoke EZMode on an Identify Server + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: EZModeInvoke + * @param action uint8_t + */ +#define emberAfFillCommandIdentifyClusterEZModeInvoke(action) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_E_Z_MODE_INVOKE_COMMAND_ID, \ + "u", \ + action); + + +/** @brief Update Commission State on the server device. + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: UpdateCommissionState + * @param action uint8_t + * @param commissionStateMask uint8_t + */ +#define emberAfFillCommandIdentifyClusterUpdateCommissionState(action, \ + commissionStateMask) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID, \ + "uu", \ + action, \ + commissionStateMask); + + +/** @brief Command description for IdentifyQueryResponse + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: IdentifyQueryResponse + * @param timeout uint16_t + */ +#define emberAfFillCommandIdentifyClusterIdentifyQueryResponse(timeout) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID, \ + "v", \ + timeout); + + +/** @brief Command description for TriggerEffect + * + * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). + * Command: TriggerEffect + * @param effectId uint8_t + * @param effectVariant uint8_t + */ +#define emberAfFillCommandIdentifyClusterTriggerEffect(effectId, \ + effectVariant) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_TRIGGER_EFFECT_COMMAND_ID, \ + "uu", \ + effectId, \ + effectVariant); + + +/** @} END Identify Commands */ + + +/** @name Groups Commands */ +// @{ +/** @brief Command description for AddGroup + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: AddGroup + * @param groupId uint16_t + * @param groupName uint8_t* + */ +#define emberAfFillCommandGroupsClusterAddGroup(groupId, \ + groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_COMMAND_ID, \ + "vs", \ + groupId, \ + groupName); + + +/** @brief Command description for ViewGroup + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: ViewGroup + * @param groupId uint16_t + */ +#define emberAfFillCommandGroupsClusterViewGroup(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_VIEW_GROUP_COMMAND_ID, \ + "v", \ + groupId); + + +/** @brief Command description for GetGroupMembership + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: GetGroupMembership + * @param groupCount uint8_t + * @param groupList uint8_t* + * @param groupListLen uint16_t + */ +#define emberAfFillCommandGroupsClusterGetGroupMembership(groupCount, \ + groupList, \ + groupListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID, \ + "ub", \ + groupCount, \ + groupList, \ + groupListLen); + + +/** @brief Command description for RemoveGroup + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: RemoveGroup + * @param groupId uint16_t + */ +#define emberAfFillCommandGroupsClusterRemoveGroup(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_GROUP_COMMAND_ID, \ + "v", \ + groupId); + + +/** @brief Command description for RemoveAllGroups + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: RemoveAllGroups + */ +#define emberAfFillCommandGroupsClusterRemoveAllGroups() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_ALL_GROUPS_COMMAND_ID, \ + ""); + + +/** @brief Command description for AddGroupIfIdentifying + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: AddGroupIfIdentifying + * @param groupId uint16_t + * @param groupName uint8_t* + */ +#define emberAfFillCommandGroupsClusterAddGroupIfIdentifying(groupId, \ + groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID, \ + "vs", \ + groupId, \ + groupName); + + +/** @brief Command description for AddGroupResponse + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: AddGroupResponse + * @param status uint8_t + * @param groupId uint16_t + */ +#define emberAfFillCommandGroupsClusterAddGroupResponse(status, \ + groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_RESPONSE_COMMAND_ID, \ + "uv", \ + status, \ + groupId); + + +/** @brief Command description for ViewGroupResponse + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: ViewGroupResponse + * @param status uint8_t + * @param groupId uint16_t + * @param groupName uint8_t* + */ +#define emberAfFillCommandGroupsClusterViewGroupResponse(status, \ + groupId, \ + groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID, \ + "uvs", \ + status, \ + groupId, \ + groupName); + + +/** @brief Command description for GetGroupMembershipResponse + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: GetGroupMembershipResponse + * @param capacity uint8_t + * @param groupCount uint8_t + * @param groupList uint8_t* + * @param groupListLen uint16_t + */ +#define emberAfFillCommandGroupsClusterGetGroupMembershipResponse(capacity, \ + groupCount, \ + groupList, \ + groupListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID, \ + "uub", \ + capacity, \ + groupCount, \ + groupList, \ + groupListLen); + + +/** @brief Command description for RemoveGroupResponse + * + * Cluster: Groups, Attributes and commands for group configuration and manipulation. + * Command: RemoveGroupResponse + * @param status uint8_t + * @param groupId uint16_t + */ +#define emberAfFillCommandGroupsClusterRemoveGroupResponse(status, \ + groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID, \ + "uv", \ + status, \ + groupId); + + +/** @} END Groups Commands */ + + +/** @name Scenes Commands */ +// @{ +/** @brief Add a scene to the scene table. Extension field sets are supported, and are inputed as arrays of the form [[cluster ID] [length] [value0...n] ...] + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: AddScene + * @param groupId uint16_t + * @param sceneId uint8_t + * @param transitionTime uint16_t + * @param sceneName uint8_t* + * @param extensionFieldSets uint8_t* + * @param extensionFieldSetsLen uint16_t + */ +#define emberAfFillCommandScenesClusterAddScene(groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ADD_SCENE_COMMAND_ID, \ + "vuvsb", \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen); + + +/** @brief Command description for ViewScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: ViewScene + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterViewScene(groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_VIEW_SCENE_COMMAND_ID, \ + "vu", \ + groupId, \ + sceneId); + + +/** @brief Command description for RemoveScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: RemoveScene + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterRemoveScene(groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_SCENE_COMMAND_ID, \ + "vu", \ + groupId, \ + sceneId); + + +/** @brief Command description for RemoveAllScenes + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: RemoveAllScenes + * @param groupId uint16_t + */ +#define emberAfFillCommandScenesClusterRemoveAllScenes(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_ALL_SCENES_COMMAND_ID, \ + "v", \ + groupId); + + +/** @brief Command description for StoreScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: StoreScene + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterStoreScene(groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_STORE_SCENE_COMMAND_ID, \ + "vu", \ + groupId, \ + sceneId); + + +/** @brief Command description for RecallScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: RecallScene + * @param groupId uint16_t + * @param sceneId uint8_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandScenesClusterRecallScene(groupId, \ + sceneId, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_RECALL_SCENE_COMMAND_ID, \ + "vuv", \ + groupId, \ + sceneId, \ + transitionTime); + + +/** @brief Command description for GetSceneMembership + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: GetSceneMembership + * @param groupId uint16_t + */ +#define emberAfFillCommandScenesClusterGetSceneMembership(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID, \ + "v", \ + groupId); + + +/** @brief Command description for AddSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: AddSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterAddSceneResponse(status, \ + groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ADD_SCENE_RESPONSE_COMMAND_ID, \ + "uvu", \ + status, \ + groupId, \ + sceneId); + + +/** @brief Command description for ViewSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: ViewSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + * @param transitionTime uint16_t + * @param sceneName uint8_t* + * @param extensionFieldSets uint8_t* + * @param extensionFieldSetsLen uint16_t + */ +#define emberAfFillCommandScenesClusterViewSceneResponse(status, \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID, \ + "uvuvsb", \ + status, \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen); + + +/** @brief Command description for RemoveSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: RemoveSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterRemoveSceneResponse(status, \ + groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID, \ + "uvu", \ + status, \ + groupId, \ + sceneId); + + +/** @brief Command description for RemoveAllScenesResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: RemoveAllScenesResponse + * @param status uint8_t + * @param groupId uint16_t + */ +#define emberAfFillCommandScenesClusterRemoveAllScenesResponse(status, \ + groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID, \ + "uv", \ + status, \ + groupId); + + +/** @brief Command description for StoreSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: StoreSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterStoreSceneResponse(status, \ + groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_STORE_SCENE_RESPONSE_COMMAND_ID, \ + "uvu", \ + status, \ + groupId, \ + sceneId); + + +/** @brief Command description for GetSceneMembershipResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: GetSceneMembershipResponse + * @param status uint8_t + * @param capacity uint8_t + * @param groupId uint16_t + * @param sceneCount uint8_t + * @param sceneList uint8_t* + * @param sceneListLen uint16_t + */ +#define emberAfFillCommandScenesClusterGetSceneMembershipResponse(status, \ + capacity, \ + groupId, \ + sceneCount, \ + sceneList, \ + sceneListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID, \ + "uuvub", \ + status, \ + capacity, \ + groupId, \ + sceneCount, \ + sceneList, \ + sceneListLen); + + +/** @brief Command description for EnhancedAddScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: EnhancedAddScene + * @param groupId uint16_t + * @param sceneId uint8_t + * @param transitionTime uint16_t + * @param sceneName uint8_t* + * @param extensionFieldSets uint8_t* + * @param extensionFieldSetsLen uint16_t + */ +#define emberAfFillCommandScenesClusterEnhancedAddScene(groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_ADD_SCENE_COMMAND_ID, \ + "vuvsb", \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen); + + +/** @brief Command description for EnhancedViewScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: EnhancedViewScene + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterEnhancedViewScene(groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID, \ + "vu", \ + groupId, \ + sceneId); + + +/** @brief Command description for CopyScene + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: CopyScene + * @param mode uint8_t + * @param groupIdFrom uint16_t + * @param sceneIdFrom uint8_t + * @param groupIdTo uint16_t + * @param sceneIdTo uint8_t + */ +#define emberAfFillCommandScenesClusterCopyScene(mode, \ + groupIdFrom, \ + sceneIdFrom, \ + groupIdTo, \ + sceneIdTo) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_COPY_SCENE_COMMAND_ID, \ + "uvuvu", \ + mode, \ + groupIdFrom, \ + sceneIdFrom, \ + groupIdTo, \ + sceneIdTo); + + +/** @brief Command description for EnhancedAddSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: EnhancedAddSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + */ +#define emberAfFillCommandScenesClusterEnhancedAddSceneResponse(status, \ + groupId, \ + sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID, \ + "uvu", \ + status, \ + groupId, \ + sceneId); + + +/** @brief Command description for EnhancedViewSceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: EnhancedViewSceneResponse + * @param status uint8_t + * @param groupId uint16_t + * @param sceneId uint8_t + * @param transitionTime uint16_t + * @param sceneName uint8_t* + * @param extensionFieldSets uint8_t* + * @param extensionFieldSetsLen uint16_t + */ +#define emberAfFillCommandScenesClusterEnhancedViewSceneResponse(status, \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID, \ + "uvuvsb", \ + status, \ + groupId, \ + sceneId, \ + transitionTime, \ + sceneName, \ + extensionFieldSets, \ + extensionFieldSetsLen); + + +/** @brief Command description for CopySceneResponse + * + * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. + * Command: CopySceneResponse + * @param status uint8_t + * @param groupIdFrom uint16_t + * @param sceneIdFrom uint8_t + */ +#define emberAfFillCommandScenesClusterCopySceneResponse(status, \ + groupIdFrom, \ + sceneIdFrom) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SCENES_CLUSTER_ID, \ + ZCL_COPY_SCENE_RESPONSE_COMMAND_ID, \ + "uvu", \ + status, \ + groupIdFrom, \ + sceneIdFrom); + + +/** @} END Scenes Commands */ + + +/** @name On/off Commands */ +// @{ +/** @brief Command description for Off + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: Off + */ +#define emberAfFillCommandOnOffClusterOff() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_OFF_COMMAND_ID, \ + ""); + + +/** @brief Command description for On + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: On + */ +#define emberAfFillCommandOnOffClusterOn() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_COMMAND_ID, \ + ""); + + +/** @brief Command description for Toggle + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: Toggle + */ +#define emberAfFillCommandOnOffClusterToggle() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_TOGGLE_COMMAND_ID, \ + ""); + + +/** @brief Command description for OffWithEffect + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: OffWithEffect + * @param effectId uint8_t + * @param effectVariant uint8_t + */ +#define emberAfFillCommandOnOffClusterOffWithEffect(effectId, \ + effectVariant) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_OFF_WITH_EFFECT_COMMAND_ID, \ + "uu", \ + effectId, \ + effectVariant); + + +/** @brief Command description for OnWithRecallGlobalScene + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: OnWithRecallGlobalScene + */ +#define emberAfFillCommandOnOffClusterOnWithRecallGlobalScene() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID, \ + ""); + + +/** @brief Command description for OnWithTimedOff + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: OnWithTimedOff + * @param onOffControl uint8_t + * @param onTime uint16_t + * @param offWaitTime uint16_t + */ +#define emberAfFillCommandOnOffClusterOnWithTimedOff(onOffControl, \ + onTime, \ + offWaitTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_WITH_TIMED_OFF_COMMAND_ID, \ + "uvv", \ + onOffControl, \ + onTime, \ + offWaitTime); + + +/** @brief Client command that turns the device off with a transition given + by the transition time in the Ember Sample transition time attribute. + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: SampleMfgSpecificOffWithTransition + */ +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOffWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + 0x1002, \ + ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID, \ + ""); + + +/** @brief Client command that turns the device on with a transition given + by the transition time in the Ember Sample transition time attribute. + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: SampleMfgSpecificOnWithTransition + */ +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + 0x1002, \ + ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID, \ + ""); + + +/** @brief Client command that toggles the device with a transition given + by the transition time in the Ember Sample transition time attribute. + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: SampleMfgSpecificToggleWithTransition + */ +#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + 0x1002, \ + ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID, \ + ""); + + +/** @brief Client command that turns the device on with a transition given + by the transition time in the Ember Sample transition time attribute. + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: SampleMfgSpecificOnWithTransition2 + */ +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition2() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + 0x1049, \ + ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID, \ + ""); + + +/** @brief Client command that toggles the device with a transition given + by the transition time in the Ember Sample transition time attribute. + * + * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. + * Command: SampleMfgSpecificToggleWithTransition2 + */ +#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition2() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, \ + 0x1049, \ + ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION2_COMMAND_ID, \ + ""); + + +/** @} END On/off Commands */ + + +/** @name On/off Switch Configuration Commands */ +// @{ +/** @} END On/off Switch Configuration Commands */ + + +/** @name Level Control Commands */ +// @{ +/** @brief Command description for MoveToLevel + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: MoveToLevel + * @param level uint8_t + * @param transitionTime uint16_t + * @param optionMask uint8_t + * @param optionOverride uint8_t + */ +#define emberAfFillCommandLevelControlClusterMoveToLevel(level, \ + transitionTime, \ + optionMask, \ + optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_LEVEL_COMMAND_ID, \ + "uvuu", \ + level, \ + transitionTime, \ + optionMask, \ + optionOverride); + + +/** @brief Command description for Move + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: Move + * @param moveMode uint8_t + * @param rate uint8_t + * @param optionMask uint8_t + * @param optionOverride uint8_t + */ +#define emberAfFillCommandLevelControlClusterMove(moveMode, \ + rate, \ + optionMask, \ + optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COMMAND_ID, \ + "uuuu", \ + moveMode, \ + rate, \ + optionMask, \ + optionOverride); + + +/** @brief Command description for Step + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: Step + * @param stepMode uint8_t + * @param stepSize uint8_t + * @param transitionTime uint16_t + * @param optionMask uint8_t + * @param optionOverride uint8_t + */ +#define emberAfFillCommandLevelControlClusterStep(stepMode, \ + stepSize, \ + transitionTime, \ + optionMask, \ + optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COMMAND_ID, \ + "uuvuu", \ + stepMode, \ + stepSize, \ + transitionTime, \ + optionMask, \ + optionOverride); + + +/** @brief Command description for Stop + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: Stop + * @param optionMask uint8_t + * @param optionOverride uint8_t + */ +#define emberAfFillCommandLevelControlClusterStop(optionMask, \ + optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STOP_COMMAND_ID, \ + "uu", \ + optionMask, \ + optionOverride); + + +/** @brief Command description for MoveToLevelWithOnOff + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: MoveToLevelWithOnOff + * @param level uint8_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandLevelControlClusterMoveToLevelWithOnOff(level, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID, \ + "uv", \ + level, \ + transitionTime); + + +/** @brief Command description for MoveWithOnOff + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: MoveWithOnOff + * @param moveMode uint8_t + * @param rate uint8_t + */ +#define emberAfFillCommandLevelControlClusterMoveWithOnOff(moveMode, \ + rate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_WITH_ON_OFF_COMMAND_ID, \ + "uu", \ + moveMode, \ + rate); + + +/** @brief Command description for StepWithOnOff + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: StepWithOnOff + * @param stepMode uint8_t + * @param stepSize uint8_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandLevelControlClusterStepWithOnOff(stepMode, \ + stepSize, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STEP_WITH_ON_OFF_COMMAND_ID, \ + "uuv", \ + stepMode, \ + stepSize, \ + transitionTime); + + +/** @brief Command description for StopWithOnOff + * + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' + * Command: StopWithOnOff + */ +#define emberAfFillCommandLevelControlClusterStopWithOnOff() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STOP_WITH_ON_OFF_COMMAND_ID, \ + ""); + + +/** @} END Level Control Commands */ + + +/** @name Alarms Commands */ +// @{ +/** @brief Command description for ResetAlarm + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: ResetAlarm + * @param alarmCode uint8_t + * @param clusterId uint16_t + */ +#define emberAfFillCommandAlarmClusterResetAlarm(alarmCode, \ + clusterId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALARM_COMMAND_ID, \ + "uv", \ + alarmCode, \ + clusterId); + + +/** @brief Command description for ResetAllAlarms + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: ResetAllAlarms + */ +#define emberAfFillCommandAlarmClusterResetAllAlarms() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALL_ALARMS_COMMAND_ID, \ + ""); + + +/** @brief Command description for GetAlarm + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: GetAlarm + */ +#define emberAfFillCommandAlarmClusterGetAlarm() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_GET_ALARM_COMMAND_ID, \ + ""); + + +/** @brief Command description for ResetAlarmLog + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: ResetAlarmLog + */ +#define emberAfFillCommandAlarmClusterResetAlarmLog() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALARM_LOG_COMMAND_ID, \ + ""); + + +/** @brief Command description for Alarm + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: Alarm + * @param alarmCode uint8_t + * @param clusterId uint16_t + */ +#define emberAfFillCommandAlarmClusterAlarm(alarmCode, \ + clusterId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_ALARM_COMMAND_ID, \ + "uv", \ + alarmCode, \ + clusterId); + + +/** @brief Command description for GetAlarmResponse + * + * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. + * Command: GetAlarmResponse + * @param status uint8_t + * @param alarmCode uint8_t + * @param clusterId uint16_t + * @param timeStamp uint32_t + */ +#define emberAfFillCommandAlarmClusterGetAlarmResponse(status, \ + alarmCode, \ + clusterId, \ + timeStamp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ALARM_CLUSTER_ID, \ + ZCL_GET_ALARM_RESPONSE_COMMAND_ID, \ + "uuvw", \ + status, \ + alarmCode, \ + clusterId, \ + timeStamp); + + +/** @} END Alarms Commands */ + + +/** @name Time Commands */ +// @{ +/** @} END Time Commands */ + + +/** @name RSSI Location Commands */ +// @{ +/** @brief Command description for SetAbsoluteLocation + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: SetAbsoluteLocation + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + * @param power int16_t + * @param pathLossExponent uint16_t + */ +#define emberAfFillCommandRssiLocationClusterSetAbsoluteLocation(coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID, \ + "vvvvv", \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent); + + +/** @brief Command description for SetDeviceConfiguration + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: SetDeviceConfiguration + * @param power int16_t + * @param pathLossExponent uint16_t + * @param calculationPeriod uint16_t + * @param numberRssiMeasurements uint8_t + * @param reportingPeriod uint16_t + */ +#define emberAfFillCommandRssiLocationClusterSetDeviceConfiguration(power, \ + pathLossExponent, \ + calculationPeriod, \ + numberRssiMeasurements, \ + reportingPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID, \ + "vvvuv", \ + power, \ + pathLossExponent, \ + calculationPeriod, \ + numberRssiMeasurements, \ + reportingPeriod); + + +/** @brief Command description for GetDeviceConfiguration + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: GetDeviceConfiguration + * @param targetAddress uint8_t* + */ +#define emberAfFillCommandRssiLocationClusterGetDeviceConfiguration(targetAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID, \ + "8", \ + targetAddress); + + +/** @brief Command description for GetLocationData + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: GetLocationData + * @param flags uint8_t + * @param numberResponses uint8_t + * @param targetAddress uint8_t* + */ +#define emberAfFillCommandRssiLocationClusterGetLocationData(flags, \ + numberResponses, \ + targetAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_GET_LOCATION_DATA_COMMAND_ID, \ + "uu8", \ + flags, \ + numberResponses, \ + targetAddress); + + +/** @brief Command description for RssiResponse + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: RssiResponse + * @param replyingDevice uint8_t* + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + * @param rssi int8_t + * @param numberRssiMeasurements uint8_t + */ +#define emberAfFillCommandRssiLocationClusterRssiResponse(replyingDevice, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + rssi, \ + numberRssiMeasurements) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_RESPONSE_COMMAND_ID, \ + "8vvvuu", \ + replyingDevice, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + rssi, \ + numberRssiMeasurements); + + +/** @brief Command description for SendPings + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: SendPings + * @param targetAddress uint8_t* + * @param numberRssiMeasurements uint8_t + * @param calculationPeriod uint16_t + */ +#define emberAfFillCommandRssiLocationClusterSendPings(targetAddress, \ + numberRssiMeasurements, \ + calculationPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SEND_PINGS_COMMAND_ID, \ + "8uv", \ + targetAddress, \ + numberRssiMeasurements, \ + calculationPeriod); + + +/** @brief Command description for AnchorNodeAnnounce + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: AnchorNodeAnnounce + * @param anchorNodeIeeeAddress uint8_t* + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + */ +#define emberAfFillCommandRssiLocationClusterAnchorNodeAnnounce(anchorNodeIeeeAddress, \ + coordinate1, \ + coordinate2, \ + coordinate3) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID, \ + "8vvv", \ + anchorNodeIeeeAddress, \ + coordinate1, \ + coordinate2, \ + coordinate3); + + +/** @brief Command description for DeviceConfigurationResponse + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: DeviceConfigurationResponse + * @param status uint8_t + * @param power int16_t + * @param pathLossExponent uint16_t + * @param calculationPeriod uint16_t + * @param numberRssiMeasurements uint8_t + * @param reportingPeriod uint16_t + */ +#define emberAfFillCommandRssiLocationClusterDeviceConfigurationResponse(status, \ + power, \ + pathLossExponent, \ + calculationPeriod, \ + numberRssiMeasurements, \ + reportingPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID, \ + "uvvvuv", \ + status, \ + power, \ + pathLossExponent, \ + calculationPeriod, \ + numberRssiMeasurements, \ + reportingPeriod); + + +/** @brief Command description for LocationDataResponse + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: LocationDataResponse + * @param status uint8_t + * @param locationType uint8_t + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + * @param power int16_t + * @param pathLossExponent uint16_t + * @param locationMethod uint8_t + * @param qualityMeasure uint8_t + * @param locationAge uint16_t + */ +#define emberAfFillCommandRssiLocationClusterLocationDataResponse(status, \ + locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent, \ + locationMethod, \ + qualityMeasure, \ + locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID, \ + "uuvvvvvuuv", \ + status, \ + locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent, \ + locationMethod, \ + qualityMeasure, \ + locationAge); + + +/** @brief Command description for LocationDataNotification + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: LocationDataNotification + * @param locationType uint8_t + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + * @param power int16_t + * @param pathLossExponent uint16_t + * @param locationMethod uint8_t + * @param qualityMeasure uint8_t + * @param locationAge uint16_t + */ +#define emberAfFillCommandRssiLocationClusterLocationDataNotification(locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent, \ + locationMethod, \ + qualityMeasure, \ + locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID, \ + "uvvvvvuuv", \ + locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + power, \ + pathLossExponent, \ + locationMethod, \ + qualityMeasure, \ + locationAge); + + +/** @brief Command description for CompactLocationDataNotification + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: CompactLocationDataNotification + * @param locationType uint8_t + * @param coordinate1 int16_t + * @param coordinate2 int16_t + * @param coordinate3 int16_t + * @param qualityMeasure uint8_t + * @param locationAge uint16_t + */ +#define emberAfFillCommandRssiLocationClusterCompactLocationDataNotification(locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + qualityMeasure, \ + locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_COMPACT_LOCATION_DATA_NOTIFICATION_COMMAND_ID, \ + "uvvvuv", \ + locationType, \ + coordinate1, \ + coordinate2, \ + coordinate3, \ + qualityMeasure, \ + locationAge); + + +/** @brief Command description for RssiPing + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: RssiPing + * @param locationType uint8_t + */ +#define emberAfFillCommandRssiLocationClusterRssiPing(locationType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_PING_COMMAND_ID, \ + "u", \ + locationType); + + +/** @brief Command description for RssiRequest + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: RssiRequest + */ +#define emberAfFillCommandRssiLocationClusterRssiRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_REQUEST_COMMAND_ID, \ + ""); + + +/** @brief Command description for ReportRssiMeasurements + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: ReportRssiMeasurements + * @param measuringDevice uint8_t* + * @param neighbors uint8_t + * @param neighborsInfo uint8_t* + * @param neighborsInfoLen uint16_t + */ +#define emberAfFillCommandRssiLocationClusterReportRssiMeasurements(measuringDevice, \ + neighbors, \ + neighborsInfo, \ + neighborsInfoLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID, \ + "8ub", \ + measuringDevice, \ + neighbors, \ + neighborsInfo, \ + neighborsInfoLen); + + +/** @brief Command description for RequestOwnLocation + * + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. + * Command: RequestOwnLocation + * @param blindNode uint8_t* + */ +#define emberAfFillCommandRssiLocationClusterRequestOwnLocation(blindNode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_REQUEST_OWN_LOCATION_COMMAND_ID, \ + "8", \ + blindNode); + + +/** @} END RSSI Location Commands */ + + +/** @name Binary Input (Basic) Commands */ +// @{ +/** @} END Binary Input (Basic) Commands */ + + +/** @name Commissioning Commands */ +// @{ +/** @brief Command description for RestartDevice + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: RestartDevice + * @param options uint8_t + * @param delay uint8_t + * @param jitter uint8_t + */ +#define emberAfFillCommandCommissioningClusterRestartDevice(options, \ + delay, \ + jitter) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTART_DEVICE_COMMAND_ID, \ + "uuu", \ + options, \ + delay, \ + jitter); + + +/** @brief Command description for SaveStartupParameters + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: SaveStartupParameters + * @param options uint8_t + * @param index uint8_t + */ +#define emberAfFillCommandCommissioningClusterSaveStartupParameters(options, \ + index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID, \ + "uu", \ + options, \ + index); + + +/** @brief Command description for RestoreStartupParameters + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: RestoreStartupParameters + * @param options uint8_t + * @param index uint8_t + */ +#define emberAfFillCommandCommissioningClusterRestoreStartupParameters(options, \ + index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID, \ + "uu", \ + options, \ + index); + + +/** @brief Command description for ResetStartupParameters + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: ResetStartupParameters + * @param options uint8_t + * @param index uint8_t + */ +#define emberAfFillCommandCommissioningClusterResetStartupParameters(options, \ + index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID, \ + "uu", \ + options, \ + index); + + +/** @brief Command description for RestartDeviceResponse + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: RestartDeviceResponse + * @param status uint8_t + */ +#define emberAfFillCommandCommissioningClusterRestartDeviceResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Command description for SaveStartupParametersResponse + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: SaveStartupParametersResponse + * @param status uint8_t + */ +#define emberAfFillCommandCommissioningClusterSaveStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Command description for RestoreStartupParametersResponse + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: RestoreStartupParametersResponse + * @param status uint8_t + */ +#define emberAfFillCommandCommissioningClusterRestoreStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTORE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Command description for ResetStartupParametersResponse + * + * Cluster: Commissioning, Attributes and commands for commissioning and managing a ZigBee device. + * Command: ResetStartupParametersResponse + * @param status uint8_t + */ +#define emberAfFillCommandCommissioningClusterResetStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @} END Commissioning Commands */ + + +/** @name Partition Commands */ +// @{ +/** @brief The TransferPartitionedFrame command is used to send a partitioned frame to another Partition cluster. + * + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. + * Command: TransferPartitionedFrame + * @param fragmentationOptions uint8_t + * @param partitionedIndicatorAndFrame uint8_t* + * @param partitionedIndicatorAndFrameLen uint16_t + */ +#define emberAfFillCommandPartitionClusterTransferPartitionedFrame(fragmentationOptions, \ + partitionedIndicatorAndFrame, \ + partitionedIndicatorAndFrameLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PARTITION_CLUSTER_ID, \ + ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID, \ + "ub", \ + fragmentationOptions, \ + partitionedIndicatorAndFrame, \ + partitionedIndicatorAndFrameLen); + + +/** @brief The ReadHandshakeParam command is used in order to read the appropriate set of parameters for each transaction to be performed by the Partition Cluster. + * + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. + * Command: ReadHandshakeParam + * @param partitionedClusterId uint16_t + * @param attributeList uint8_t* + * @param attributeListLen uint16_t + */ +#define emberAfFillCommandPartitionClusterReadHandshakeParam(partitionedClusterId, \ + attributeList, \ + attributeListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PARTITION_CLUSTER_ID, \ + ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID, \ + "vb", \ + partitionedClusterId, \ + attributeList, \ + attributeListLen); + + +/** @brief The WriteHandshakeParam command is used during the handshake phase in order to write the appropriate parameters for each transaction to be performed by the Partition Cluster. + * + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. + * Command: WriteHandshakeParam + * @param partitionedClusterId uint16_t + * @param writeAttributeRecords uint8_t* + * @param writeAttributeRecordsLen uint16_t + */ +#define emberAfFillCommandPartitionClusterWriteHandshakeParam(partitionedClusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PARTITION_CLUSTER_ID, \ + ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID, \ + "vb", \ + partitionedClusterId, \ + writeAttributeRecords, \ + writeAttributeRecordsLen); + + +/** @brief MultipleACK command. + * + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. + * Command: MultipleAck + * @param ackOptions uint8_t + * @param firstFrameIdAndNackList uint8_t* + * @param firstFrameIdAndNackListLen uint16_t + */ +#define emberAfFillCommandPartitionClusterMultipleAck(ackOptions, \ + firstFrameIdAndNackList, \ + firstFrameIdAndNackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PARTITION_CLUSTER_ID, \ + ZCL_MULTIPLE_ACK_COMMAND_ID, \ + "ub", \ + ackOptions, \ + firstFrameIdAndNackList, \ + firstFrameIdAndNackListLen); + + +/** @brief The ReadHandshakeParamResponse command is used in order to response to the corresponding ReadHandshakeParam command in order to communicate the appropriate set of parameters configured for each transaction to be performed by the Partition Cluster. + * + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. + * Command: ReadHandshakeParamResponse + * @param partitionedClusterId uint16_t + * @param readAttributeStatusRecords uint8_t* + * @param readAttributeStatusRecordsLen uint16_t + */ +#define emberAfFillCommandPartitionClusterReadHandshakeParamResponse(partitionedClusterId, \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PARTITION_CLUSTER_ID, \ + ZCL_READ_HANDSHAKE_PARAM_RESPONSE_COMMAND_ID, \ + "vb", \ + partitionedClusterId, \ + readAttributeStatusRecords, \ + readAttributeStatusRecordsLen); + + +/** @} END Partition Commands */ + + +/** @name Over the Air Bootloading Commands */ +// @{ +/** @brief This command is generated when the upgrade server wishes to notify the clients of the available OTA upgrade image. The command can be sent as unicast which provides a way for the server to force the upgrade on the client. The command can also be sent as broadcast or multicast to certain class of clients (for example, the ones that have matching manufacturing and device ids). + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: ImageNotify + * @param payloadType uint8_t + * @param queryJitter uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param newFileVersion uint32_t + */ +#define emberAfFillCommandOtaBootloadClusterImageNotify(payloadType, \ + queryJitter, \ + manufacturerId, \ + imageType, \ + newFileVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_NOTIFY_COMMAND_ID, \ + "uuvvw", \ + payloadType, \ + queryJitter, \ + manufacturerId, \ + imageType, \ + newFileVersion); + + +/** @brief This command is generated upon receipt of an Image Notify command to indicate that the client is looking for the next firmware image to upgrade to. The client may also choose to send the command periodically to the server. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: QueryNextImageRequest + * @param fieldControl uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param currentFileVersion uint32_t + * @param hardwareVersion uint16_t + */ +#define emberAfFillCommandOtaBootloadClusterQueryNextImageRequest(fieldControl, \ + manufacturerId, \ + imageType, \ + currentFileVersion, \ + hardwareVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID, \ + "uvvwv", \ + fieldControl, \ + manufacturerId, \ + imageType, \ + currentFileVersion, \ + hardwareVersion); + + +/** @brief This command is generated upon receipt of an QueryNextImageRequest command to response whether the server has a valid OTA upgrade image for the client or not. If the server has the file, information regarding the file and OTA upgrade process will be included in the command. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: QueryNextImageResponse + * @param status uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param imageSize uint32_t + */ +#define emberAfFillCommandOtaBootloadClusterQueryNextImageResponse(status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + imageSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID, \ + "uvvww", \ + status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + imageSize); + + +/** @brief This command is generated by the client to request blocks of OTA upgrade file data. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: ImageBlockRequest + * @param fieldControl uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param fileOffset uint32_t + * @param maxDataSize uint8_t + * @param requestNodeAddress uint8_t* + */ +#define emberAfFillCommandOtaBootloadClusterImageBlockRequest(fieldControl, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + maxDataSize, \ + requestNodeAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID, \ + "uvvwwu8", \ + fieldControl, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + maxDataSize, \ + requestNodeAddress); + + +/** @brief This command is generated by the client to request pages of OTA upgrade file data. A page would contain multiple blocks of data. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: ImagePageRequest + * @param fieldControl uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param fileOffset uint32_t + * @param maxDataSize uint8_t + * @param pageSize uint16_t + * @param responseSpacing uint16_t + * @param requestNodeAddress uint8_t* + */ +#define emberAfFillCommandOtaBootloadClusterImagePageRequest(fieldControl, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + maxDataSize, \ + pageSize, \ + responseSpacing, \ + requestNodeAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID, \ + "uvvwwuvv8", \ + fieldControl, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + maxDataSize, \ + pageSize, \ + responseSpacing, \ + requestNodeAddress); + + +/** @brief This command is generated by the server in response to the block or page request command. If the server has the data available, it will reply back with a SUCCESS status. For other error cases, it may reply with status WAIT_FOR_DATA (server does not have the data available yet) or ABORT (invalid requested parameters or other failure cases). + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: ImageBlockResponse + * @param status uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param fileOffset uint32_t + * @param dataSize uint8_t + * @param imageData uint8_t* + * @param imageDataLen uint16_t + */ +#define emberAfFillCommandOtaBootloadClusterImageBlockResponse(status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + dataSize, \ + imageData, \ + imageDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID, \ + "uvvwwub", \ + status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + fileOffset, \ + dataSize, \ + imageData, \ + imageDataLen); + + +/** @brief This command is generated by the client to notify the server of the end of the upgrade process. The process may end with success or error status. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: UpgradeEndRequest + * @param status uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + */ +#define emberAfFillCommandOtaBootloadClusterUpgradeEndRequest(status, \ + manufacturerId, \ + imageType, \ + fileVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_UPGRADE_END_REQUEST_COMMAND_ID, \ + "uvvw", \ + status, \ + manufacturerId, \ + imageType, \ + fileVersion); + + +/** @brief This command is generated by the server in response to the upgrade request in order to let the client know when to upgrade to running new firmware image. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: UpgradeEndResponse + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param currentTime uint32_t + * @param upgradeTime uint32_t + */ +#define emberAfFillCommandOtaBootloadClusterUpgradeEndResponse(manufacturerId, \ + imageType, \ + fileVersion, \ + currentTime, \ + upgradeTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_UPGRADE_END_RESPONSE_COMMAND_ID, \ + "vvwww", \ + manufacturerId, \ + imageType, \ + fileVersion, \ + currentTime, \ + upgradeTime); + + +/** @brief This command is generated by the client to request a file that is specific to itself. The intention is to provide a way for the client to request non-OTA upgrade file. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: QuerySpecificFileRequest + * @param requestNodeAddress uint8_t* + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param currentZigbeeStackVersion uint16_t + */ +#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileRequest(requestNodeAddress, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + currentZigbeeStackVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID, \ + "8vvwv", \ + requestNodeAddress, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + currentZigbeeStackVersion); + + +/** @brief This command is generated upon receipt of an QuerySpecificFileRequest command to response whether the server has a valid file for the client or not. If the server has the file, information regarding the file and OTA process will be included in the command. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. + * Command: QuerySpecificFileResponse + * @param status uint8_t + * @param manufacturerId uint16_t + * @param imageType uint16_t + * @param fileVersion uint32_t + * @param imageSize uint32_t + */ +#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileResponse(status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + imageSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID, \ + "uvvww", \ + status, \ + manufacturerId, \ + imageType, \ + fileVersion, \ + imageSize); + + +/** @} END Over the Air Bootloading Commands */ + + +/** @name Power Profile Commands */ +// @{ +/** @brief The PowerProfileRequest Command is generated by a device supporting the client side of the Power Profile cluster in order to request the Power Profile of a server device. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileRequest + * @param powerProfileId uint8_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_REQUEST_COMMAND_ID, \ + "u", \ + powerProfileId); + + +/** @brief The PowerProfileStateRequest Command is generated in order to retrieve the identifiers of current Power Profiles. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileStateRequest + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileStateRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID, \ + ""); + + +/** @brief The GetPowerProfilePriceResponse command allows a device (client) to communicate the cost associated to the selected Power Profile to another device (server) requesting it. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetPowerProfilePriceResponse + * @param powerProfileId uint8_t + * @param currency uint16_t + * @param price uint32_t + * @param priceTrailingDigit uint8_t + */ +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceResponse(powerProfileId, \ + currency, \ + price, \ + priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID, \ + "uvwu", \ + powerProfileId, \ + currency, \ + price, \ + priceTrailingDigit); + + +/** @brief The GetOverallSchedulePriceResponse command allows a device (client) to communicate the overall cost associated to all Power Profiles scheduled to another device (server) requesting it. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetOverallSchedulePriceResponse + * @param currency uint16_t + * @param price uint32_t + * @param priceTrailingDigit uint8_t + */ +#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePriceResponse(currency, \ + price, \ + priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID, \ + "vwu", \ + currency, \ + price, \ + priceTrailingDigit); + + +/** @brief The EnergyPhasesScheduleNotification Command is generated by a device supporting the client side of the Power Profile cluster in order to schedule the start of the selected Power Profile and its phases. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleNotification + * @param powerProfileId uint8_t + * @param numOfScheduledPhases uint8_t + * @param scheduledPhases uint8_t* + * @param scheduledPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleNotification(powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID, \ + "uub", \ + powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen); + + +/** @brief This command is generated by the client side of Power Profile cluster as a reply to the EnergyPhasesScheduleRequest command. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleResponse + * @param powerProfileId uint8_t + * @param numOfScheduledPhases uint8_t + * @param scheduledPhases uint8_t* + * @param scheduledPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleResponse(powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID, \ + "uub", \ + powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen); + + +/** @brief The PowerProfileScheduleConstraintsRequest Command is generated by a device supporting the client side of the Power Profile cluster in order to request the constraints -if set- of Power Profile of a client device, in order to set the proper boundaries for the scheduling when calculating the schedules. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileScheduleConstraintsRequest + * @param powerProfileId uint8_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID, \ + "u", \ + powerProfileId); + + +/** @brief The EnergyPhasesScheduleStateRequest Command is generated by a device supporting the client side of the Power Profile cluster to check the states of the scheduling of a power profile, which is supported in the device implementing the server side of Power Profile cluster. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleStateRequest + * @param powerProfileId uint8_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID, \ + "u", \ + powerProfileId); + + +/** @brief The Get Power Profile Price Extended Response command allows a device (client) to communicate the cost associated to all Power Profiles scheduled to another device (server) requesting it according to the specific options contained in the Get Power Profile Price Extended Response. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetPowerProfilePriceExtendedResponse + * @param powerProfileId uint8_t + * @param currency uint16_t + * @param price uint32_t + * @param priceTrailingDigit uint8_t + */ +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtendedResponse(powerProfileId, \ + currency, \ + price, \ + priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID, \ + "uvwu", \ + powerProfileId, \ + currency, \ + price, \ + priceTrailingDigit); + + +/** @brief The PowerProfileNotification Command is generated by a device supporting the server side of the Power Profile cluster in order to send the information of the specific parameters (such as Peak power and others) belonging to each phase. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileNotification + * @param totalProfileNum uint8_t + * @param powerProfileId uint8_t + * @param numOfTransferredPhases uint8_t + * @param transferredPhases uint8_t* + * @param transferredPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileNotification(totalProfileNum, \ + powerProfileId, \ + numOfTransferredPhases, \ + transferredPhases, \ + transferredPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID, \ + "uuub", \ + totalProfileNum, \ + powerProfileId, \ + numOfTransferredPhases, \ + transferredPhases, \ + transferredPhasesLen); + + +/** @brief This command is generated by the server side of Power Profile cluster as a reply to the PowerProfileRequest command. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileResponse + * @param totalProfileNum uint8_t + * @param powerProfileId uint8_t + * @param numOfTransferredPhases uint8_t + * @param transferredPhases uint8_t* + * @param transferredPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileResponse(totalProfileNum, \ + powerProfileId, \ + numOfTransferredPhases, \ + transferredPhases, \ + transferredPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID, \ + "uuub", \ + totalProfileNum, \ + powerProfileId, \ + numOfTransferredPhases, \ + transferredPhases, \ + transferredPhasesLen); + + +/** @brief The PowerProfileStateResponse command allows a device (server) to communicate its current Power Profile(s) to another device (client) that previously requested them. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileStateResponse + * @param powerProfileCount uint8_t + * @param powerProfileRecords uint8_t* + * @param powerProfileRecordsLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileStateResponse(powerProfileCount, \ + powerProfileRecords, \ + powerProfileRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID, \ + "ub", \ + powerProfileCount, \ + powerProfileRecords, \ + powerProfileRecordsLen); + + +/** @brief The GetPowerProfilePrice Command is generated by the server (e.g. White goods) in order to retrieve the cost associated to a specific Power profile. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetPowerProfilePrice + * @param powerProfileId uint8_t + */ +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePrice(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID, \ + "u", \ + powerProfileId); + + +/** @brief The PowerProfileStateNotification Command is generated by the server (e.g. White goods) in order to update the state of the power profile and the current energy phase. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfilesStateNotification + * @param powerProfileCount uint8_t + * @param powerProfileRecords uint8_t* + * @param powerProfileRecordsLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfilesStateNotification(powerProfileCount, \ + powerProfileRecords, \ + powerProfileRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID, \ + "ub", \ + powerProfileCount, \ + powerProfileRecords, \ + powerProfileRecordsLen); + + +/** @brief The GetOverallSchedulePrice Command is generated by the server (e.g. White goods) in order to retrieve the overall cost associated to all the Power Profiles scheduled by the scheduler (the device supporting the Power Profile cluster client side) for the next 24 hours. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetOverallSchedulePrice + */ +#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePrice() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID, \ + ""); + + +/** @brief The EnergyPhasesScheduleRequest Command is generated by the server (e.g. White goods) in order to retrieve from the scheduler (e.g. Home Gateway) the schedule (if available) associated to the specific Power Profile carried in the payload. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleRequest + * @param powerProfileId uint8_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID, \ + "u", \ + powerProfileId); + + +/** @brief The EnergyPhasesScheduleStateResponse Command is generated by the server (e.g. White goods) in order to reply to a EnergyPhasesScheduleStateRequest command about the scheduling states that are set in the server side. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleStateResponse + * @param powerProfileId uint8_t + * @param numOfScheduledPhases uint8_t + * @param scheduledPhases uint8_t* + * @param scheduledPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateResponse(powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID, \ + "uub", \ + powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen); + + +/** @brief The EnergyPhasesScheduleStateNotification Command is generated by the server (e.g. White goods) in order to notify (un-solicited command) a client side about the scheduling states that are set in the server side. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: EnergyPhasesScheduleStateNotification + * @param powerProfileId uint8_t + * @param numOfScheduledPhases uint8_t + * @param scheduledPhases uint8_t* + * @param scheduledPhasesLen uint16_t + */ +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateNotification(powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID, \ + "uub", \ + powerProfileId, \ + numOfScheduledPhases, \ + scheduledPhases, \ + scheduledPhasesLen); + + +/** @brief The PowerProfileScheduleConstraintsNotification Command is generated by a device supporting the server side of the Power Profile cluster to notify the client side of this cluster about the imposed constraints and let the scheduler (i.e. the entity supporting the Power Profile cluster client side) to set the proper boundaries for the scheduling. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileScheduleConstraintsNotification + * @param powerProfileId uint8_t + * @param startAfter uint16_t + * @param stopBefore uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsNotification(powerProfileId, \ + startAfter, \ + stopBefore) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID, \ + "uvv", \ + powerProfileId, \ + startAfter, \ + stopBefore); + + +/** @brief The PowerProfileScheduleConstraintsResponse Command is generated by a device supporting the server side of the Power Profile cluster to reply to a client side of this cluster which sent a PowerProfileScheduleConstraintsRequest. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: PowerProfileScheduleConstraintsResponse + * @param powerProfileId uint8_t + * @param startAfter uint16_t + * @param stopBefore uint16_t + */ +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsResponse(powerProfileId, \ + startAfter, \ + stopBefore) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID, \ + "uvv", \ + powerProfileId, \ + startAfter, \ + stopBefore); + + +/** @brief The Get Power Profile Price Extended command is generated by the server (e.g., White Goods) in order to retrieve the cost associated to a specific Power profile considering specific conditions described in the option field (e.g., a specific time). + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). + * Command: GetPowerProfilePriceExtended + * @param options uint8_t + * @param powerProfileId uint8_t + * @param powerProfileStartTime uint16_t + */ +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtended(options, \ + powerProfileId, \ + powerProfileStartTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID, \ + "uuv", \ + options, \ + powerProfileId, \ + powerProfileStartTime); + + +/** @} END Power Profile Commands */ + + +/** @name Appliance Control Commands */ +// @{ +/** @brief This basic message is used to remotely control and to program household appliances. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: ExecutionOfACommand + * @param commandId uint8_t + */ +#define emberAfFillCommandApplianceControlClusterExecutionOfACommand(commandId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID, \ + "u", \ + commandId); + + +/** @brief This basic message is used to retrieve Household Appliances status. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: SignalState + */ +#define emberAfFillCommandApplianceControlClusterSignalState() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_SIGNAL_STATE_COMMAND_ID, \ + ""); + + +/** @brief This basic message is used to set appliance functions, i.e. information regarding the execution of an appliance cycle. Condition parameters such as start time or finish time information could be provided through this command. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: WriteFunctions + * @param functionId uint16_t + * @param functionDataType uint8_t + * @param functionData uint8_t* + * @param functionDataLen uint16_t + */ +#define emberAfFillCommandApplianceControlClusterWriteFunctions(functionId, \ + functionDataType, \ + functionData, \ + functionDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_WRITE_FUNCTIONS_COMMAND_ID, \ + "vub", \ + functionId, \ + functionDataType, \ + functionData, \ + functionDataLen); + + +/** @brief This command shall be used to resume the normal behavior of a household appliance being in pause mode after receiving a Overload Pause command. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: OverloadPauseResume + */ +#define emberAfFillCommandApplianceControlClusterOverloadPauseResume() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID, \ + ""); + + +/** @brief This command shall be used to pause the household appliance as a consequence of an imminent overload event. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: OverloadPause + */ +#define emberAfFillCommandApplianceControlClusterOverloadPause() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_OVERLOAD_PAUSE_COMMAND_ID, \ + ""); + + +/** @brief This basic message is used to send warnings the household appliance as a consequence of a possible overload event, or the notification of the end of the warning state. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: OverloadWarning + * @param warningEvent uint8_t + */ +#define emberAfFillCommandApplianceControlClusterOverloadWarning(warningEvent) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_OVERLOAD_WARNING_COMMAND_ID, \ + "u", \ + warningEvent); + + +/** @brief This command shall be used to return household appliance status, according to Appliance Status Values and Remote Enable Flags Values. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: SignalStateResponse + * @param applianceStatus uint8_t + * @param remoteEnableFlagsAndDeviceStatus2 uint8_t + * @param applianceStatus2 uint32_t + */ +#define emberAfFillCommandApplianceControlClusterSignalStateResponse(applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID, \ + "uux", \ + applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2); + + +/** @brief This command shall be used to return household appliance status, automatically when appliance status changes. + * + * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. + * Command: SignalStateNotification + * @param applianceStatus uint8_t + * @param remoteEnableFlagsAndDeviceStatus2 uint8_t + * @param applianceStatus2 uint32_t + */ +#define emberAfFillCommandApplianceControlClusterSignalStateNotification(applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ + ZCL_SIGNAL_STATE_NOTIFICATION_COMMAND_ID, \ + "uux", \ + applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2); + + +/** @} END Appliance Control Commands */ + + +/** @name Poll Control Commands */ +// @{ +/** @brief The Poll Control Cluster server sends out a Check-in command to the devices to which it is paired based on the server's Check-in Interval attribute. + * + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. + * Command: CheckIn + */ +#define emberAfFillCommandPollControlClusterCheckIn() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_CHECK_IN_COMMAND_ID, \ + ""); + + +/** @brief The Check-in Response is sent in response to the receipt of a Check-in command. + * + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. + * Command: CheckInResponse + * @param startFastPolling uint8_t + * @param fastPollTimeout uint16_t + */ +#define emberAfFillCommandPollControlClusterCheckInResponse(startFastPolling, \ + fastPollTimeout) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_CHECK_IN_RESPONSE_COMMAND_ID, \ + "uv", \ + startFastPolling, \ + fastPollTimeout); + + +/** @brief The Fast Poll Stop command is used to stop the fast poll mode initiated by the Check-in response. + * + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. + * Command: FastPollStop + */ +#define emberAfFillCommandPollControlClusterFastPollStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_FAST_POLL_STOP_COMMAND_ID, \ + ""); + + +/** @brief The Set Long Poll Interval command is used to set the read only Long Poll Interval Attribute. + * + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. + * Command: SetLongPollInterval + * @param newLongPollInterval uint32_t + */ +#define emberAfFillCommandPollControlClusterSetLongPollInterval(newLongPollInterval) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID, \ + "w", \ + newLongPollInterval); + + +/** @brief The Set Short Poll Interval command is used to set the read only Short Poll Interval Attribute. + * + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. + * Command: SetShortPollInterval + * @param newShortPollInterval uint16_t + */ +#define emberAfFillCommandPollControlClusterSetShortPollInterval(newShortPollInterval) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID, \ + "v", \ + newShortPollInterval); + + +/** @} END Poll Control Commands */ + + +/** @name Green Power Commands */ +// @{ +/** @brief From GPP to GPS to tunnel GP frame. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpNotification + * @param options uint16_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param gpdEndpoint uint8_t + * @param gpdSecurityFrameCounter uint32_t + * @param gpdCommandId uint8_t + * @param gpdCommandPayload uint8_t* + * @param gppShortAddress uint16_t + * @param gppDistance uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpNotification(options, \ + gpdSrcId, \ + gpdIeee, \ + gpdEndpoint, \ + gpdSecurityFrameCounter, \ + gpdCommandId, \ + gpdCommandPayload, \ + gppShortAddress, \ + gppDistance) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_NOTIFICATION_COMMAND_ID, \ + "vw8uwusvu", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + gpdEndpoint, \ + gpdSecurityFrameCounter, \ + gpdCommandId, \ + gpdCommandPayload, \ + gppShortAddress, \ + gppDistance); + + +/** @brief From GPP to GPSs in entire network to get pairing indication related to GPD for Proxy Table update. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpPairingSearch + * @param options uint16_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpPairingSearch(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_SEARCH_COMMAND_ID, \ + "vw8u", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint); + + +/** @brief From GPP to neighbor GPPs to indicate GP Notification sent in unicast mode. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpTunnelingStop + * @param options uint8_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param gpdSecurityFrameCounter uint32_t + * @param gppShortAddress uint16_t + * @param gppDistance int8_t + */ +#define emberAfFillCommandGreenPowerClusterGpTunnelingStop(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter, \ + gppShortAddress, \ + gppDistance) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TUNNELING_STOP_COMMAND_ID, \ + "uw8uwvu", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter, \ + gppShortAddress, \ + gppDistance); + + +/** @brief From GPP to GPS to tunnel GPD commissioning data. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpCommissioningNotification + * @param options uint16_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param gpdSecurityFrameCounter uint32_t + * @param gpdCommandId uint8_t + * @param gpdCommandPayload uint8_t* + * @param gppShortAddress uint16_t + * @param gppLink uint8_t + * @param mic uint32_t + */ +#define emberAfFillCommandGreenPowerClusterGpCommissioningNotification(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter, \ + gpdCommandId, \ + gpdCommandPayload, \ + gppShortAddress, \ + gppLink, \ + mic) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID, \ + "vw8uwusvuw", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter, \ + gpdCommandId, \ + gpdCommandPayload, \ + gppShortAddress, \ + gppLink, \ + mic); + + +/** @brief To enable commissioning mode of the sink, over the air + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpSinkCommissioningMode + * @param options uint8_t + * @param gpmAddrForSecurity uint16_t + * @param gpmAddrForPairing uint16_t + * @param sinkEndpoint uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpSinkCommissioningMode(options, \ + gpmAddrForSecurity, \ + gpmAddrForPairing, \ + sinkEndpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID, \ + "uvvu", \ + options, \ + gpmAddrForSecurity, \ + gpmAddrForPairing, \ + sinkEndpoint); + + +/** @brief To configure GPD Command Translation Table. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpTranslationTableUpdate + * @param options uint16_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param translations uint8_t* + * @param translationsLen uint16_t + */ +#define emberAfFillCommandGreenPowerClusterGpTranslationTableUpdate(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + translations, \ + translationsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID, \ + "vw8ub", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + translations, \ + translationsLen); + + +/** @brief To provide GPD Command Translation Table content. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpTranslationTableRequest + * @param startIndex uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpTranslationTableRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID, \ + "u", \ + startIndex); + + +/** @brief To configure Sink Table. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpPairingConfiguration + * @param actions uint8_t + * @param options uint16_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param deviceId uint8_t + * @param groupListCount uint8_t + * @param groupList uint8_t* + * @param groupListLen uint16_t + * @param gpdAssignedAlias uint16_t + * @param groupcastRadius uint8_t + * @param securityOptions uint8_t + * @param gpdSecurityFrameCounter uint32_t + * @param gpdSecurityKey uint8_t* + * @param numberOfPairedEndpoints uint8_t + * @param pairedEndpoints uint8_t* + * @param pairedEndpointsLen uint16_t + * @param applicationInformation uint8_t + * @param manufacturerId uint16_t + * @param modeId uint16_t + * @param numberOfGpdCommands uint8_t + * @param gpdCommandIdList uint8_t* + * @param gpdCommandIdListLen uint16_t + * @param clusterIdListCount uint8_t + * @param clusterListServer uint8_t* + * @param clusterListServerLen uint16_t + * @param clusterListClient uint8_t* + * @param clusterListClientLen uint16_t + * @param switchInformationLength uint8_t + * @param switchConfiguration uint8_t + * @param currentContactStatus uint8_t + * @param totalNumberOfReports uint8_t + * @param numberOfReports uint8_t + * @param reportDescriptor uint8_t* + * @param reportDescriptorLen uint16_t + */ +#define emberAfFillCommandGreenPowerClusterGpPairingConfiguration(actions, \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + deviceId, \ + groupListCount, \ + groupList, \ + groupListLen, \ + gpdAssignedAlias, \ + groupcastRadius, \ + securityOptions, \ + gpdSecurityFrameCounter, \ + gpdSecurityKey, \ + numberOfPairedEndpoints, \ + pairedEndpoints, \ + pairedEndpointsLen, \ + applicationInformation, \ + manufacturerId, \ + modeId, \ + numberOfGpdCommands, \ + gpdCommandIdList, \ + gpdCommandIdListLen, \ + clusterIdListCount, \ + clusterListServer, \ + clusterListServerLen, \ + clusterListClient, \ + clusterListClientLen, \ + switchInformationLength, \ + switchConfiguration, \ + currentContactStatus, \ + totalNumberOfReports, \ + numberOfReports, \ + reportDescriptor, \ + reportDescriptorLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID, \ + "uvw8uuubvuuwGubuvvububbuuuuub", \ + actions, \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + deviceId, \ + groupListCount, \ + groupList, \ + groupListLen, \ + gpdAssignedAlias, \ + groupcastRadius, \ + securityOptions, \ + gpdSecurityFrameCounter, \ + gpdSecurityKey, \ + numberOfPairedEndpoints, \ + pairedEndpoints, \ + pairedEndpointsLen, \ + applicationInformation, \ + manufacturerId, \ + modeId, \ + numberOfGpdCommands, \ + gpdCommandIdList, \ + gpdCommandIdListLen, \ + clusterIdListCount, \ + clusterListServer, \ + clusterListServerLen, \ + clusterListClient, \ + clusterListClientLen, \ + switchInformationLength, \ + switchConfiguration, \ + currentContactStatus, \ + totalNumberOfReports, \ + numberOfReports, \ + reportDescriptor, \ + reportDescriptorLen); + + +/** @brief To read out selected Sink Table Entries, by index or by GPD ID. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpSinkTableRequest + * @param options uint8_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param index uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpSinkTableRequest(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID, \ + "uw8uu", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + index); + + +/** @brief To reply with read-out Proxy Table entries, by index or by GPD ID. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpProxyTableResponse + * @param status uint8_t + * @param totalNumberOfNonEmptyProxyTableEntries uint8_t + * @param startIndex uint8_t + * @param entriesCount uint8_t + * @param proxyTableEntries uint8_t* + * @param proxyTableEntriesLen uint16_t + */ +#define emberAfFillCommandGreenPowerClusterGpProxyTableResponse(status, \ + totalNumberOfNonEmptyProxyTableEntries, \ + startIndex, \ + entriesCount, \ + proxyTableEntries, \ + proxyTableEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID, \ + "uuuub", \ + status, \ + totalNumberOfNonEmptyProxyTableEntries, \ + startIndex, \ + entriesCount, \ + proxyTableEntries, \ + proxyTableEntriesLen); + + +/** @brief From GPS to GPP to acknowledge GP Notification received in unicast mode. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpNotificationResponse + * @param options uint8_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param gpdSecurityFrameCounter uint32_t + */ +#define emberAfFillCommandGreenPowerClusterGpNotificationResponse(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID, \ + "uw8uw", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdSecurityFrameCounter); + + +/** @brief From GPS to the entire network to (de)register for tunneling service, or for removing GPD from the network. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpPairing + * @param options uint32_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param sinkIeeeAddress uint8_t* + * @param sinkNwkAddress uint16_t + * @param sinkGroupId uint16_t + * @param deviceId uint8_t + * @param gpdSecurityFrameCounter uint32_t + * @param gpdKey uint8_t* + * @param assignedAlias uint16_t + * @param groupcastRadius uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpPairing(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + sinkIeeeAddress, \ + sinkNwkAddress, \ + sinkGroupId, \ + deviceId, \ + gpdSecurityFrameCounter, \ + gpdKey, \ + assignedAlias, \ + groupcastRadius) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_COMMAND_ID, \ + "xw8u8vvuwGvu", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + sinkIeeeAddress, \ + sinkNwkAddress, \ + sinkGroupId, \ + deviceId, \ + gpdSecurityFrameCounter, \ + gpdKey, \ + assignedAlias, \ + groupcastRadius); + + +/** @brief From GPS to GPPs in the whole network to indicate commissioning mode. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpProxyCommissioningMode + * @param options uint8_t + * @param commissioningWindow uint16_t + * @param channel uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpProxyCommissioningMode(options, \ + commissioningWindow, \ + channel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID, \ + "uvu", \ + options, \ + commissioningWindow, \ + channel); + + +/** @brief From GPS to selected GPP, to provide data to be transmitted to Rx-capable GPD. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpResponse + * @param options uint8_t + * @param tempMasterShortAddress uint16_t + * @param tempMasterTxChannel uint8_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param gpdCommandId uint8_t + * @param gpdCommandPayload uint8_t* + */ +#define emberAfFillCommandGreenPowerClusterGpResponse(options, \ + tempMasterShortAddress, \ + tempMasterTxChannel, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdCommandId, \ + gpdCommandPayload) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_RESPONSE_COMMAND_ID, \ + "uvuw8uus", \ + options, \ + tempMasterShortAddress, \ + tempMasterTxChannel, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + gpdCommandId, \ + gpdCommandPayload); + + +/** @brief To provide GPD Command Translation Table content. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpTranslationTableResponse + * @param status uint8_t + * @param options uint8_t + * @param totalNumberOfEntries uint8_t + * @param startIndex uint8_t + * @param entriesCount uint8_t + * @param translationTableList uint8_t* + * @param translationTableListLen uint16_t + */ +#define emberAfFillCommandGreenPowerClusterGpTranslationTableResponse(status, \ + options, \ + totalNumberOfEntries, \ + startIndex, \ + entriesCount, \ + translationTableList, \ + translationTableListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_RESPONSE_COMMAND_ID, \ + "uuuuub", \ + status, \ + options, \ + totalNumberOfEntries, \ + startIndex, \ + entriesCount, \ + translationTableList, \ + translationTableListLen); + + +/** @brief To selected Proxy Table entries, by index or by GPD ID. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpSinkTableResponse + * @param status uint8_t + * @param totalNumberofNonEmptySinkTableEntries uint8_t + * @param startIndex uint8_t + * @param sinkTableEntriesCount uint8_t + * @param sinkTableEntries uint8_t* + * @param sinkTableEntriesLen uint16_t + */ +#define emberAfFillCommandGreenPowerClusterGpSinkTableResponse(status, \ + totalNumberofNonEmptySinkTableEntries, \ + startIndex, \ + sinkTableEntriesCount, \ + sinkTableEntries, \ + sinkTableEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID, \ + "uuuub", \ + status, \ + totalNumberofNonEmptySinkTableEntries, \ + startIndex, \ + sinkTableEntriesCount, \ + sinkTableEntries, \ + sinkTableEntriesLen); + + +/** @brief To request selected Proxy Table entries, by index or by GPD ID. + * + * Cluster: Green Power, The Green Power cluster defines the format of the commands exchanged when handling GPDs. + * Command: GpProxyTableRequest + * @param options uint8_t + * @param gpdSrcId uint32_t + * @param gpdIeee uint8_t* + * @param endpoint uint8_t + * @param index uint8_t + */ +#define emberAfFillCommandGreenPowerClusterGpProxyTableRequest(options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID, \ + "uw8uu", \ + options, \ + gpdSrcId, \ + gpdIeee, \ + endpoint, \ + index); + + +/** @} END Green Power Commands */ + + +/** @name Keep-Alive Commands */ +// @{ +/** @} END Keep-Alive Commands */ + + +/** @name Shade Configuration Commands */ +// @{ +/** @} END Shade Configuration Commands */ + + +/** @name Door Lock Commands */ +// @{ +/** @brief Locks the door + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: LockDoor + * @param PIN uint8_t* + */ +#define emberAfFillCommandDoorLockClusterLockDoor(PIN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_LOCK_DOOR_COMMAND_ID, \ + "s", \ + PIN); + + +/** @brief Unlocks the door + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: UnlockDoor + * @param PIN uint8_t* + */ +#define emberAfFillCommandDoorLockClusterUnlockDoor(PIN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_DOOR_COMMAND_ID, \ + "s", \ + PIN); + + +/** @brief Toggles the door lock from its current state to the opposite state locked or unlocked. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: Toggle + * @param pin uint8_t* + */ +#define emberAfFillCommandDoorLockClusterToggle(pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_TOGGLE_COMMAND_ID, \ + "s", \ + pin); + + +/** @brief Unlock the door with a timeout. When the timeout expires, the door will automatically re-lock. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: UnlockWithTimeout + * @param timeoutInSeconds uint16_t + * @param pin uint8_t* + */ +#define emberAfFillCommandDoorLockClusterUnlockWithTimeout(timeoutInSeconds, \ + pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID, \ + "vs", \ + timeoutInSeconds, \ + pin); + + +/** @brief Retrieve a log record at a specified index. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetLogRecord + * @param logIndex uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetLogRecord(logIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_LOG_RECORD_COMMAND_ID, \ + "v", \ + logIndex); + + +/** @brief Set the PIN for a specified user id. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetPin + * @param userId uint16_t + * @param userStatus uint8_t + * @param userType uint8_t + * @param pin uint8_t* + */ +#define emberAfFillCommandDoorLockClusterSetPin(userId, \ + userStatus, \ + userType, \ + pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_PIN_COMMAND_ID, \ + "vuus", \ + userId, \ + userStatus, \ + userType, \ + pin); + + +/** @brief Retrieve PIN information for a user with a specific user ID. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetPin + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetPin(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_PIN_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Clear the PIN for a user with a specific user ID + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearPin + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterClearPin(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_PIN_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Clear all PIN codes on the lock for all users. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearAllPins + */ +#define emberAfFillCommandDoorLockClusterClearAllPins() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_PINS_COMMAND_ID, \ + ""); + + +/** @brief Set the status value for a specified user ID. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetUserStatus + * @param userId uint16_t + * @param userStatus uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetUserStatus(userId, \ + userStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_STATUS_COMMAND_ID, \ + "vu", \ + userId, \ + userStatus); + + +/** @brief Retrieve the status byte for a specific user. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetUserStatus + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetUserStatus(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_STATUS_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Set the schedule of days during the week that the associated user based on the user ID will have access to the lock and will be able to operate it. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetWeekdaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + * @param daysMask uint8_t + * @param startHour uint8_t + * @param startMinute uint8_t + * @param endHour uint8_t + * @param endMinute uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetWeekdaySchedule(scheduleId, \ + userId, \ + daysMask, \ + startHour, \ + startMinute, \ + endHour, \ + endMinute) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID, \ + "uvuuuuu", \ + scheduleId, \ + userId, \ + daysMask, \ + startHour, \ + startMinute, \ + endHour, \ + endMinute); + + +/** @brief Retrieve a weekday schedule for doorlock user activation for a specific schedule id and user id. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetWeekdaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetWeekdaySchedule(scheduleId, \ + userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID, \ + "uv", \ + scheduleId, \ + userId); + + +/** @brief Clear a weekday schedule for doorlock user activation for a specific schedule id and user id. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearWeekdaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterClearWeekdaySchedule(scheduleId, \ + userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID, \ + "uv", \ + scheduleId, \ + userId); + + +/** @brief Set a door lock user id activation schedule according to a specific absolute local start and end time + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetYeardaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + * @param localStartTime uint32_t + * @param localEndTime uint32_t + */ +#define emberAfFillCommandDoorLockClusterSetYeardaySchedule(scheduleId, \ + userId, \ + localStartTime, \ + localEndTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID, \ + "uvww", \ + scheduleId, \ + userId, \ + localStartTime, \ + localEndTime); + + +/** @brief Retrieve a yearday schedule for a specific scheduleId and userId + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetYeardaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetYeardaySchedule(scheduleId, \ + userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID, \ + "uv", \ + scheduleId, \ + userId); + + +/** @brief Clear a yearday schedule for a specific scheduleId and userId + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearYeardaySchedule + * @param scheduleId uint8_t + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterClearYeardaySchedule(scheduleId, \ + userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID, \ + "uv", \ + scheduleId, \ + userId); + + +/** @brief Set the holiday schedule for a specific user + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetHolidaySchedule + * @param scheduleId uint8_t + * @param localStartTime uint32_t + * @param localEndTime uint32_t + * @param operatingModeDuringHoliday uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetHolidaySchedule(scheduleId, \ + localStartTime, \ + localEndTime, \ + operatingModeDuringHoliday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID, \ + "uwwu", \ + scheduleId, \ + localStartTime, \ + localEndTime, \ + operatingModeDuringHoliday); + + +/** @brief Retrieve a holiday schedule for a specific scheduleId + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetHolidaySchedule + * @param scheduleId uint8_t + */ +#define emberAfFillCommandDoorLockClusterGetHolidaySchedule(scheduleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID, \ + "u", \ + scheduleId); + + +/** @brief Clear a holiday schedule for a specific scheduleId + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearHolidaySchedule + * @param scheduleId uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearHolidaySchedule(scheduleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID, \ + "u", \ + scheduleId); + + +/** @brief Set the type value for a user based on user ID. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetUserType + * @param userId uint16_t + * @param userType uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetUserType(userId, \ + userType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_TYPE_COMMAND_ID, \ + "vu", \ + userId, \ + userType); + + +/** @brief Retrieve the type for a specific user based on the user ID. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetUserType + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetUserType(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_TYPE_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Set the PIN for a specified user id. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetRfid + * @param userId uint16_t + * @param userStatus uint8_t + * @param userType uint8_t + * @param id uint8_t* + */ +#define emberAfFillCommandDoorLockClusterSetRfid(userId, \ + userStatus, \ + userType, \ + id) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_RFID_COMMAND_ID, \ + "vuus", \ + userId, \ + userStatus, \ + userType, \ + id); + + +/** @brief Retrieve RFID ID information for a user with a specific user ID. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetRfid + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterGetRfid(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_RFID_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Clear the RFID ID for a user with a specific user ID + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearRfid + * @param userId uint16_t + */ +#define emberAfFillCommandDoorLockClusterClearRfid(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_RFID_COMMAND_ID, \ + "v", \ + userId); + + +/** @brief Clear all RFID ID codes on the lock for all users. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearAllRfids + */ +#define emberAfFillCommandDoorLockClusterClearAllRfids() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_RFIDS_COMMAND_ID, \ + ""); + + +/** @brief Indicates lock success or failure + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: LockDoorResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterLockDoorResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Indicates unlock success or failure + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: UnlockDoorResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterUnlockDoorResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Response provided to the toggle command, indicates whether the toggle was successful or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ToggleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterToggleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_TOGGLE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Response provided to unlock with specific timeout. This command indicates whether the unlock command was successful or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: UnlockWithTimeoutResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterUnlockWithTimeoutResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the specific log record requested. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetLogRecordResponse + * @param logEntryId uint16_t + * @param timestamp uint32_t + * @param eventType uint8_t + * @param source uint8_t + * @param eventIdOrAlarmCode uint8_t + * @param userId uint16_t + * @param pin uint8_t* + */ +#define emberAfFillCommandDoorLockClusterGetLogRecordResponse(logEntryId, \ + timestamp, \ + eventType, \ + source, \ + eventIdOrAlarmCode, \ + userId, \ + pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID, \ + "vwuuuvs", \ + logEntryId, \ + timestamp, \ + eventType, \ + source, \ + eventIdOrAlarmCode, \ + userId, \ + pin); + + +/** @brief Indicates whether the setting of the PIN was successful or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetPinResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetPinResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_PIN_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the PIN requested according to the user ID passed. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetPinResponse + * @param userId uint16_t + * @param userStatus uint8_t + * @param userType uint8_t + * @param pin uint8_t* + */ +#define emberAfFillCommandDoorLockClusterGetPinResponse(userId, \ + userStatus, \ + userType, \ + pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_PIN_RESPONSE_COMMAND_ID, \ + "vuus", \ + userId, \ + userStatus, \ + userType, \ + pin); + + +/** @brief Returns success or failure depending on whether the PIN was cleared or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearPinResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearPinResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns success or failure depending on whether the PINs were cleared or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearAllPinsResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearAllPinsResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns success or failure depending on whether the user status was set or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetUserStatusResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetUserStatusResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the user status. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetUserStatusResponse + * @param userId uint16_t + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterGetUserStatusResponse(userId, \ + status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID, \ + "vu", \ + userId, \ + status); + + +/** @brief Returns the status of setting the weekday schedule + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetWeekdayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetWeekdayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the weekday schedule requested. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetWeekdayScheduleResponse + * @param scheduleId uint8_t + * @param userId uint16_t + * @param status uint8_t + * @param daysMask uint8_t + * @param startHour uint8_t + * @param startMinute uint8_t + * @param endHour uint8_t + * @param endMinute uint8_t + */ +#define emberAfFillCommandDoorLockClusterGetWeekdayScheduleResponse(scheduleId, \ + userId, \ + status, \ + daysMask, \ + startHour, \ + startMinute, \ + endHour, \ + endMinute) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "uvuuuuuu", \ + scheduleId, \ + userId, \ + status, \ + daysMask, \ + startHour, \ + startMinute, \ + endHour, \ + endMinute); + + +/** @brief Returns the status of clearing the weekday schedule + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearWeekdayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearWeekdayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns success or failure depending on whether the yearday schedule was set or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetYeardayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetYeardayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the yearday schedule requested + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetYeardayScheduleResponse + * @param scheduleId uint8_t + * @param userId uint16_t + * @param status uint8_t + * @param localStartTime uint32_t + * @param localEndTime uint32_t + */ +#define emberAfFillCommandDoorLockClusterGetYeardayScheduleResponse(scheduleId, \ + userId, \ + status, \ + localStartTime, \ + localEndTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "uvuww", \ + scheduleId, \ + userId, \ + status, \ + localStartTime, \ + localEndTime); + + +/** @brief Returns success or failure depending on whether the yearday schedule was removed or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearYeardayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearYeardayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns success or failure depending on whether the holiday schedule was set or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetHolidayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetHolidayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the holiday schedule requested + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetHolidayScheduleResponse + * @param scheduleId uint8_t + * @param status uint8_t + * @param localStartTime uint32_t + * @param localEndTime uint32_t + * @param operatingModeDuringHoliday uint8_t + */ +#define emberAfFillCommandDoorLockClusterGetHolidayScheduleResponse(scheduleId, \ + status, \ + localStartTime, \ + localEndTime, \ + operatingModeDuringHoliday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "uuwwu", \ + scheduleId, \ + status, \ + localStartTime, \ + localEndTime, \ + operatingModeDuringHoliday); + + +/** @brief Returns success or failure depending on whether the holiday schedule was removed or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearHolidayScheduleResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearHolidayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief returns success or failure depending on whether the user type was set or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetUserTypeResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetUserTypeResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the user type for the user ID requested. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetUserTypeResponse + * @param userId uint16_t + * @param userType uint8_t + */ +#define emberAfFillCommandDoorLockClusterGetUserTypeResponse(userId, \ + userType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID, \ + "vu", \ + userId, \ + userType); + + +/** @brief Indicates whether the setting of the RFID ID was successful or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: SetRfidResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterSetRfidResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_RFID_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns the RFID ID requested according to the user ID passed. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: GetRfidResponse + * @param userId uint16_t + * @param userStatus uint8_t + * @param userType uint8_t + * @param rfid uint8_t* + */ +#define emberAfFillCommandDoorLockClusterGetRfidResponse(userId, \ + userStatus, \ + userType, \ + rfid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_RFID_RESPONSE_COMMAND_ID, \ + "vuus", \ + userId, \ + userStatus, \ + userType, \ + rfid); + + +/** @brief Returns success or failure depending on whether the RFID ID was cleared or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearRfidResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearRfidResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Returns success or failure depending on whether the RFID IDs were cleared or not. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ClearAllRfidsResponse + * @param status uint8_t + */ +#define emberAfFillCommandDoorLockClusterClearAllRfidsResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID, \ + "u", \ + status); + + +/** @brief Indicates that an operation event has taken place. Includes the associated event information. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: OperationEventNotification + * @param source uint8_t + * @param eventCode uint8_t + * @param userId uint16_t + * @param pin uint8_t* + * @param timeStamp uint32_t + * @param data uint8_t* + */ +#define emberAfFillCommandDoorLockClusterOperationEventNotification(source, \ + eventCode, \ + userId, \ + pin, \ + timeStamp, \ + data) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID, \ + "uuvsws", \ + source, \ + eventCode, \ + userId, \ + pin, \ + timeStamp, \ + data); + + +/** @brief Indicates that a programming event has taken place. Includes the associated programming event information. + * + * Cluster: Door Lock, Provides an interface into a generic way to secure a door. + * Command: ProgrammingEventNotification + * @param source uint8_t + * @param eventCode uint8_t + * @param userId uint16_t + * @param pin uint8_t* + * @param userType uint8_t + * @param userStatus uint8_t + * @param timeStamp uint32_t + * @param data uint8_t* + */ +#define emberAfFillCommandDoorLockClusterProgrammingEventNotification(source, \ + eventCode, \ + userId, \ + pin, \ + userType, \ + userStatus, \ + timeStamp, \ + data) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID, \ + "uuvsuuws", \ + source, \ + eventCode, \ + userId, \ + pin, \ + userType, \ + userStatus, \ + timeStamp, \ + data); + + +/** @} END Door Lock Commands */ + + +/** @name Window Covering Commands */ +// @{ +/** @brief Moves window covering to InstalledOpenLimit - Lift and InstalledOpenLimit - Tilt + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringUpOpen + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringUpOpen() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID, \ + ""); + + +/** @brief Moves window covering to InstalledClosedLimit - Lift and InstalledCloseLimit - Tilt + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringDownClose + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringDownClose() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID, \ + ""); + + +/** @brief Stop any adjusting of window covering + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringStop + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_STOP_COMMAND_ID, \ + ""); + + +/** @brief Goto lift value specified + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringGoToLiftValue + * @param liftValue uint16_t + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftValue(liftValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID, \ + "v", \ + liftValue); + + +/** @brief Goto lift percentage specified + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringGoToLiftPercentage + * @param percentageLiftValue uint8_t + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftPercentage(percentageLiftValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID, \ + "u", \ + percentageLiftValue); + + +/** @brief Goto tilt value specified + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringGoToTiltValue + * @param tiltValue uint16_t + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltValue(tiltValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID, \ + "v", \ + tiltValue); + + +/** @brief Goto tilt percentage specified + * + * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. + * Command: WindowCoveringGoToTiltPercentage + * @param percentageTiltValue uint8_t + */ +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltPercentage(percentageTiltValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID, \ + "u", \ + percentageTiltValue); + + +/** @} END Window Covering Commands */ + + +/** @name Barrier Control Commands */ +// @{ +/** @brief Command to instruct a barrier to go to a percent open state. + * + * Cluster: Barrier Control, This cluster provides control of a barrier (garage door). + * Command: BarrierControlGoToPercent + * @param percentOpen uint8_t + */ +#define emberAfFillCommandBarrierControlClusterBarrierControlGoToPercent(percentOpen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BARRIER_CONTROL_CLUSTER_ID, \ + ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID, \ + "u", \ + percentOpen); + + +/** @brief Command that instructs the barrier to stop moving. + * + * Cluster: Barrier Control, This cluster provides control of a barrier (garage door). + * Command: BarrierControlStop + */ +#define emberAfFillCommandBarrierControlClusterBarrierControlStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BARRIER_CONTROL_CLUSTER_ID, \ + ZCL_BARRIER_CONTROL_STOP_COMMAND_ID, \ + ""); + + +/** @} END Barrier Control Commands */ + + +/** @name Pump Configuration and Control Commands */ +// @{ +/** @} END Pump Configuration and Control Commands */ + + +/** @name Thermostat Commands */ +// @{ +/** @brief Command description for SetpointRaiseLower + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: SetpointRaiseLower + * @param mode uint8_t + * @param amount int8_t + */ +#define emberAfFillCommandThermostatClusterSetpointRaiseLower(mode, \ + amount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID, \ + "uu", \ + mode, \ + amount); + + +/** @brief Command description for SetWeeklySchedule + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: SetWeeklySchedule + * @param numberOfTransitionsForSequence uint8_t + * @param dayOfWeekForSequence uint8_t + * @param modeForSequence uint8_t + * @param payload uint8_t* + * @param payloadLen uint16_t + */ +#define emberAfFillCommandThermostatClusterSetWeeklySchedule(numberOfTransitionsForSequence, \ + dayOfWeekForSequence, \ + modeForSequence, \ + payload, \ + payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID, \ + "uuub", \ + numberOfTransitionsForSequence, \ + dayOfWeekForSequence, \ + modeForSequence, \ + payload, \ + payloadLen); + + +/** @brief Command description for GetWeeklySchedule + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: GetWeeklySchedule + * @param daysToReturn uint8_t + * @param modeToReturn uint8_t + */ +#define emberAfFillCommandThermostatClusterGetWeeklySchedule(daysToReturn, \ + modeToReturn) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID, \ + "uu", \ + daysToReturn, \ + modeToReturn); + + +/** @brief The Clear Weekly Schedule command is used to clear the weekly schedule. + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: ClearWeeklySchedule + */ +#define emberAfFillCommandThermostatClusterClearWeeklySchedule() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID, \ + ""); + + +/** @brief The Get Relay Status Log command is used to query the thermostat internal relay status log. + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: GetRelayStatusLog + */ +#define emberAfFillCommandThermostatClusterGetRelayStatusLog() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID, \ + ""); + + +/** @brief The Current Weekly Schedule Command is sent from the server in response to the Get Weekly Schedule Command. + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: CurrentWeeklySchedule + * @param numberOfTransitionsForSequence uint8_t + * @param dayOfWeekForSequence uint8_t + * @param modeForSequence uint8_t + * @param payload uint8_t* + * @param payloadLen uint16_t + */ +#define emberAfFillCommandThermostatClusterCurrentWeeklySchedule(numberOfTransitionsForSequence, \ + dayOfWeekForSequence, \ + modeForSequence, \ + payload, \ + payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_CURRENT_WEEKLY_SCHEDULE_COMMAND_ID, \ + "uuub", \ + numberOfTransitionsForSequence, \ + dayOfWeekForSequence, \ + modeForSequence, \ + payload, \ + payloadLen); + + +/** @brief This command is sent from the thermostat cluster server in response to the Get Relay Status Log. + * + * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. + * Command: RelayStatusLog + * @param timeOfDay uint16_t + * @param relayStatus uint16_t + * @param localTemperature int16_t + * @param humidityInPercentage uint8_t + * @param setpoint int16_t + * @param unreadEntries uint16_t + */ +#define emberAfFillCommandThermostatClusterRelayStatusLog(timeOfDay, \ + relayStatus, \ + localTemperature, \ + humidityInPercentage, \ + setpoint, \ + unreadEntries) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_RELAY_STATUS_LOG_COMMAND_ID, \ + "vvvuvv", \ + timeOfDay, \ + relayStatus, \ + localTemperature, \ + humidityInPercentage, \ + setpoint, \ + unreadEntries); + + +/** @} END Thermostat Commands */ + + +/** @name Fan Control Commands */ +// @{ +/** @} END Fan Control Commands */ + + +/** @name Dehumidification Control Commands */ +// @{ +/** @} END Dehumidification Control Commands */ + + +/** @name Thermostat User Interface Configuration Commands */ +// @{ +/** @} END Thermostat User Interface Configuration Commands */ + + +/** @name Color Control Commands */ +// @{ +/** @brief Move to specified hue. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveToHue + * @param hue uint8_t + * @param direction uint8_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveToHue(hue, \ + direction, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_HUE_COMMAND_ID, \ + "uuvuu", \ + hue, \ + direction, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move hue up or down at specified rate. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveHue + * @param moveMode uint8_t + * @param rate uint8_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveHue(moveMode, \ + rate, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_HUE_COMMAND_ID, \ + "uuuu", \ + moveMode, \ + rate, \ + optionsMask, \ + optionsOverride); + + +/** @brief Step hue up or down by specified size at specified rate. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: StepHue + * @param stepMode uint8_t + * @param stepSize uint8_t + * @param transitionTime uint8_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterStepHue(stepMode, \ + stepSize, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_HUE_COMMAND_ID, \ + "uuuuu", \ + stepMode, \ + stepSize, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move to specified saturation. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveToSaturation + * @param saturation uint8_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveToSaturation(saturation, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_SATURATION_COMMAND_ID, \ + "uvuu", \ + saturation, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move saturation up or down at specified rate. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveSaturation + * @param moveMode uint8_t + * @param rate uint8_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveSaturation(moveMode, \ + rate, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_SATURATION_COMMAND_ID, \ + "uuuu", \ + moveMode, \ + rate, \ + optionsMask, \ + optionsOverride); + + +/** @brief Step saturation up or down by specified size at specified rate. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: StepSaturation + * @param stepMode uint8_t + * @param stepSize uint8_t + * @param transitionTime uint8_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterStepSaturation(stepMode, \ + stepSize, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_SATURATION_COMMAND_ID, \ + "uuuuu", \ + stepMode, \ + stepSize, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move to hue and saturation. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveToHueAndSaturation + * @param hue uint8_t + * @param saturation uint8_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveToHueAndSaturation(hue, \ + saturation, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, \ + "uuvuu", \ + hue, \ + saturation, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move to specified color. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveToColor + * @param colorX uint16_t + * @param colorY uint16_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveToColor(colorX, \ + colorY, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_COLOR_COMMAND_ID, \ + "vvvuu", \ + colorX, \ + colorY, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Moves the color. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveColor + * @param rateX int16_t + * @param rateY int16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveColor(rateX, \ + rateY, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COLOR_COMMAND_ID, \ + "vvuu", \ + rateX, \ + rateY, \ + optionsMask, \ + optionsOverride); + + +/** @brief Steps the lighting to a specific color. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: StepColor + * @param stepX int16_t + * @param stepY int16_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterStepColor(stepX, \ + stepY, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COLOR_COMMAND_ID, \ + "vvvuu", \ + stepX, \ + stepY, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Move to a specific color temperature. + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveToColorTemperature + * @param colorTemperature uint16_t + * @param transitionTime uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveToColorTemperature(colorTemperature, \ + transitionTime, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID, \ + "vvuu", \ + colorTemperature, \ + transitionTime, \ + optionsMask, \ + optionsOverride); + + +/** @brief Command description for EnhancedMoveToHue + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: EnhancedMoveToHue + * @param enhancedHue uint16_t + * @param direction uint8_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandColorControlClusterEnhancedMoveToHue(enhancedHue, \ + direction, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID, \ + "vuv", \ + enhancedHue, \ + direction, \ + transitionTime); + + +/** @brief Command description for EnhancedMoveHue + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: EnhancedMoveHue + * @param moveMode uint8_t + * @param rate uint16_t + */ +#define emberAfFillCommandColorControlClusterEnhancedMoveHue(moveMode, \ + rate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_HUE_COMMAND_ID, \ + "uv", \ + moveMode, \ + rate); + + +/** @brief Command description for EnhancedStepHue + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: EnhancedStepHue + * @param stepMode uint8_t + * @param stepSize uint16_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandColorControlClusterEnhancedStepHue(stepMode, \ + stepSize, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_STEP_HUE_COMMAND_ID, \ + "uvv", \ + stepMode, \ + stepSize, \ + transitionTime); + + +/** @brief Command description for EnhancedMoveToHueAndSaturation + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: EnhancedMoveToHueAndSaturation + * @param enhancedHue uint16_t + * @param saturation uint8_t + * @param transitionTime uint16_t + */ +#define emberAfFillCommandColorControlClusterEnhancedMoveToHueAndSaturation(enhancedHue, \ + saturation, \ + transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, \ + "vuv", \ + enhancedHue, \ + saturation, \ + transitionTime); + + +/** @brief Command description for ColorLoopSet + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: ColorLoopSet + * @param updateFlags uint8_t + * @param action uint8_t + * @param direction uint8_t + * @param time uint16_t + * @param startHue uint16_t + */ +#define emberAfFillCommandColorControlClusterColorLoopSet(updateFlags, \ + action, \ + direction, \ + time, \ + startHue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_COLOR_LOOP_SET_COMMAND_ID, \ + "uuuvv", \ + updateFlags, \ + action, \ + direction, \ + time, \ + startHue); + + +/** @brief Command description for StopMoveStep + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: StopMoveStep + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterStopMoveStep(optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STOP_MOVE_STEP_COMMAND_ID, \ + "uu", \ + optionsMask, \ + optionsOverride); + + +/** @brief Command description for MoveColorTemperature + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: MoveColorTemperature + * @param moveMode uint8_t + * @param rate uint16_t + * @param colorTemperatureMinimum uint16_t + * @param colorTemperatureMaximum uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterMoveColorTemperature(moveMode, \ + rate, \ + colorTemperatureMinimum, \ + colorTemperatureMaximum, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID, \ + "uvvvuu", \ + moveMode, \ + rate, \ + colorTemperatureMinimum, \ + colorTemperatureMaximum, \ + optionsMask, \ + optionsOverride); + + +/** @brief Command description for StepColorTemperature + * + * Cluster: Color Control, Attributes and commands for controlling the color properties of a color-capable light. + * Command: StepColorTemperature + * @param stepMode uint8_t + * @param stepSize uint16_t + * @param transitionTime uint16_t + * @param colorTemperatureMinimum uint16_t + * @param colorTemperatureMaximum uint16_t + * @param optionsMask uint8_t + * @param optionsOverride uint8_t + */ +#define emberAfFillCommandColorControlClusterStepColorTemperature(stepMode, \ + stepSize, \ + transitionTime, \ + colorTemperatureMinimum, \ + colorTemperatureMaximum, \ + optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID, \ + "uvvvvuu", \ + stepMode, \ + stepSize, \ + transitionTime, \ + colorTemperatureMinimum, \ + colorTemperatureMaximum, \ + optionsMask, \ + optionsOverride); + + +/** @} END Color Control Commands */ + + +/** @name Ballast Configuration Commands */ +// @{ +/** @} END Ballast Configuration Commands */ + + +/** @name Illuminance Measurement Commands */ +// @{ +/** @} END Illuminance Measurement Commands */ + + +/** @name Illuminance Level Sensing Commands */ +// @{ +/** @} END Illuminance Level Sensing Commands */ + + +/** @name Temperature Measurement Commands */ +// @{ +/** @} END Temperature Measurement Commands */ + + +/** @name Pressure Measurement Commands */ +// @{ +/** @} END Pressure Measurement Commands */ + + +/** @name Flow Measurement Commands */ +// @{ +/** @} END Flow Measurement Commands */ + + +/** @name Relative Humidity Measurement Commands */ +// @{ +/** @} END Relative Humidity Measurement Commands */ + + +/** @name Occupancy Sensing Commands */ +// @{ +/** @} END Occupancy Sensing Commands */ + + +/** @name Carbon Monoxide Concentration Measurement Commands */ +// @{ +/** @} END Carbon Monoxide Concentration Measurement Commands */ + + +/** @name Carbon Dioxide Concentration Measurement Commands */ +// @{ +/** @} END Carbon Dioxide Concentration Measurement Commands */ + + +/** @name Ethylene Concentration Measurement Commands */ +// @{ +/** @} END Ethylene Concentration Measurement Commands */ + + +/** @name Ethylene Oxide Concentration Measurement Commands */ +// @{ +/** @} END Ethylene Oxide Concentration Measurement Commands */ + + +/** @name Hydrogen Concentration Measurement Commands */ +// @{ +/** @} END Hydrogen Concentration Measurement Commands */ + + +/** @name Hydrogen Sulphide Concentration Measurement Commands */ +// @{ +/** @} END Hydrogen Sulphide Concentration Measurement Commands */ + + +/** @name Nitric Oxide Concentration Measurement Commands */ +// @{ +/** @} END Nitric Oxide Concentration Measurement Commands */ + + +/** @name Nitrogen Dioxide Concentration Measurement Commands */ +// @{ +/** @} END Nitrogen Dioxide Concentration Measurement Commands */ + + +/** @name Oxygen Concentration Measurement Commands */ +// @{ +/** @} END Oxygen Concentration Measurement Commands */ + + +/** @name Ozone Concentration Measurement Commands */ +// @{ +/** @} END Ozone Concentration Measurement Commands */ + + +/** @name Sulfur Dioxide Concentration Measurement Commands */ +// @{ +/** @} END Sulfur Dioxide Concentration Measurement Commands */ + + +/** @name Dissolved Oxygen Concentration Measurement Commands */ +// @{ +/** @} END Dissolved Oxygen Concentration Measurement Commands */ + + +/** @name Bromate Concentration Measurement Commands */ +// @{ +/** @} END Bromate Concentration Measurement Commands */ + + +/** @name Chloramines Concentration Measurement Commands */ +// @{ +/** @} END Chloramines Concentration Measurement Commands */ + + +/** @name Chlorine Concentration Measurement Commands */ +// @{ +/** @} END Chlorine Concentration Measurement Commands */ + + +/** @name Fecal coliform and E. Coli Concentration Measurement Commands */ +// @{ +/** @} END Fecal coliform and E. Coli Concentration Measurement Commands */ + + +/** @name Fluoride Concentration Measurement Commands */ +// @{ +/** @} END Fluoride Concentration Measurement Commands */ + + +/** @name Haloacetic Acids Concentration Measurement Commands */ +// @{ +/** @} END Haloacetic Acids Concentration Measurement Commands */ + + +/** @name Total Trihalomethanes Concentration Measurement Commands */ +// @{ +/** @} END Total Trihalomethanes Concentration Measurement Commands */ + + +/** @name Total Coliform Bacteria Concentration Measurement Commands */ +// @{ +/** @} END Total Coliform Bacteria Concentration Measurement Commands */ + + +/** @name Turbidity Concentration Measurement Commands */ +// @{ +/** @} END Turbidity Concentration Measurement Commands */ + + +/** @name Copper Concentration Measurement Commands */ +// @{ +/** @} END Copper Concentration Measurement Commands */ + + +/** @name Lead Concentration Measurement Commands */ +// @{ +/** @} END Lead Concentration Measurement Commands */ + + +/** @name Manganese Concentration Measurement Commands */ +// @{ +/** @} END Manganese Concentration Measurement Commands */ + + +/** @name Sulfate Concentration Measurement Commands */ +// @{ +/** @} END Sulfate Concentration Measurement Commands */ + + +/** @name Bromodichloromethane Concentration Measurement Commands */ +// @{ +/** @} END Bromodichloromethane Concentration Measurement Commands */ + + +/** @name Bromoform Concentration Measurement Commands */ +// @{ +/** @} END Bromoform Concentration Measurement Commands */ + + +/** @name Chlorodibromomethane Concentration Measurement Commands */ +// @{ +/** @} END Chlorodibromomethane Concentration Measurement Commands */ + + +/** @name Chloroform Concentration Measurement Commands */ +// @{ +/** @} END Chloroform Concentration Measurement Commands */ + + +/** @name Sodium Concentration Measurement Commands */ +// @{ +/** @} END Sodium Concentration Measurement Commands */ + + +/** @name IAS Zone Commands */ +// @{ +/** @brief Command description for zoneEnrollResponse + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: ZoneEnrollResponse + * @param enrollResponseCode uint8_t + * @param zoneId uint8_t + */ +#define emberAfFillCommandIasZoneClusterZoneEnrollResponse(enrollResponseCode, \ + zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID, \ + "uu", \ + enrollResponseCode, \ + zoneId); + + +/** @brief Used to tell the IAS Zone server to commence normal operation mode + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: InitiateNormalOperationMode + */ +#define emberAfFillCommandIasZoneClusterInitiateNormalOperationMode() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID, \ + ""); + + +/** @brief Certain IAS Zone servers may have operational configurations that could be configured OTA or locally on the device. This command enables them to be remotely placed into a test mode so that the user or installer may configure their field of view, sensitivity, and other operational parameters. + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: InitiateTestMode + * @param testModeDuration uint8_t + * @param currentZoneSensitivityLevel uint8_t + */ +#define emberAfFillCommandIasZoneClusterInitiateTestMode(testModeDuration, \ + currentZoneSensitivityLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_TEST_MODE_COMMAND_ID, \ + "uu", \ + testModeDuration, \ + currentZoneSensitivityLevel); + + +/** @brief Command description for zoneStatusChangeNotification + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: ZoneStatusChangeNotification + * @param zoneStatus uint16_t + * @param extendedStatus uint8_t + * @param zoneId uint8_t + * @param delay uint16_t + */ +#define emberAfFillCommandIasZoneClusterZoneStatusChangeNotification(zoneStatus, \ + extendedStatus, \ + zoneId, \ + delay) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID, \ + "vuuv", \ + zoneStatus, \ + extendedStatus, \ + zoneId, \ + delay); + + +/** @brief Command description for zoneEnrollRequest + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: ZoneEnrollRequest + * @param zoneType uint16_t + * @param manufacturerCode uint16_t + */ +#define emberAfFillCommandIasZoneClusterZoneEnrollRequest(zoneType, \ + manufacturerCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID, \ + "vv", \ + zoneType, \ + manufacturerCode); + + +/** @brief Confirms that the IAS Zone server has commenced normal operation mode. + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: InitiateNormalOperationModeResponse + */ +#define emberAfFillCommandIasZoneClusterInitiateNormalOperationModeResponse() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID, \ + ""); + + +/** @brief Confirms that the IAS Zone server has commenced test mode and that the IAS Zone client should treat any Zone Status Change Notification commands received from the sending IAS Zone server as being in response to test events. + * + * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. + * Command: InitiateTestModeResponse + */ +#define emberAfFillCommandIasZoneClusterInitiateTestModeResponse() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID, \ + ""); + + +/** @} END IAS Zone Commands */ + + +/** @name IAS ACE Commands */ +// @{ +/** @brief Command description for Arm + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: Arm + * @param armMode uint8_t + * @param armDisarmCode uint8_t* + * @param zoneId uint8_t + */ +#define emberAfFillCommandIasAceClusterArm(armMode, \ + armDisarmCode, \ + zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ARM_COMMAND_ID, \ + "usu", \ + armMode, \ + armDisarmCode, \ + zoneId); + + +/** @brief Command description for Bypass + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: Bypass + * @param numberOfZones uint8_t + * @param zoneIds uint8_t* + * @param zoneIdsLen uint16_t + * @param armDisarmCode uint8_t* + */ +#define emberAfFillCommandIasAceClusterBypass(numberOfZones, \ + zoneIds, \ + zoneIdsLen, \ + armDisarmCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_BYPASS_COMMAND_ID, \ + "ubs", \ + numberOfZones, \ + zoneIds, \ + zoneIdsLen, \ + armDisarmCode); + + +/** @brief Command description for Emergency + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: Emergency + */ +#define emberAfFillCommandIasAceClusterEmergency() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_EMERGENCY_COMMAND_ID, \ + ""); + + +/** @brief Command description for Fire + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: Fire + */ +#define emberAfFillCommandIasAceClusterFire() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_FIRE_COMMAND_ID, \ + ""); + + +/** @brief Command description for Panic + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: Panic + */ +#define emberAfFillCommandIasAceClusterPanic() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_PANIC_COMMAND_ID, \ + ""); + + +/** @brief Command description for GetZoneIdMap + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneIdMap + */ +#define emberAfFillCommandIasAceClusterGetZoneIdMap() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_ID_MAP_COMMAND_ID, \ + ""); + + +/** @brief Command description for GetZoneInformation + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneInformation + * @param zoneId uint8_t + */ +#define emberAfFillCommandIasAceClusterGetZoneInformation(zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_INFORMATION_COMMAND_ID, \ + "u", \ + zoneId); + + +/** @brief Used by the ACE client to request an update to the status of the ACE server + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetPanelStatus + */ +#define emberAfFillCommandIasAceClusterGetPanelStatus() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_PANEL_STATUS_COMMAND_ID, \ + ""); + + +/** @brief Used by the ACE client to retrieve the bypassed zones + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetBypassedZoneList + */ +#define emberAfFillCommandIasAceClusterGetBypassedZoneList() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID, \ + ""); + + +/** @brief Used by the ACE client to request an update to the zone status of the ACE server + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneStatus + * @param startingZoneId uint8_t + * @param maxNumberOfZoneIds uint8_t + * @param zoneStatusMaskFlag uint8_t + * @param zoneStatusMask uint16_t + */ +#define emberAfFillCommandIasAceClusterGetZoneStatus(startingZoneId, \ + maxNumberOfZoneIds, \ + zoneStatusMaskFlag, \ + zoneStatusMask) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_STATUS_COMMAND_ID, \ + "uuuv", \ + startingZoneId, \ + maxNumberOfZoneIds, \ + zoneStatusMaskFlag, \ + zoneStatusMask); + + +/** @brief Command description for ArmResponse + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: ArmResponse + * @param armNotification uint8_t + */ +#define emberAfFillCommandIasAceClusterArmResponse(armNotification) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ARM_RESPONSE_COMMAND_ID, \ + "u", \ + armNotification); + + +/** @brief Command description for GetZoneIdMapResponse + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneIdMapResponse + * @param section0 uint16_t + * @param section1 uint16_t + * @param section2 uint16_t + * @param section3 uint16_t + * @param section4 uint16_t + * @param section5 uint16_t + * @param section6 uint16_t + * @param section7 uint16_t + * @param section8 uint16_t + * @param section9 uint16_t + * @param section10 uint16_t + * @param section11 uint16_t + * @param section12 uint16_t + * @param section13 uint16_t + * @param section14 uint16_t + * @param section15 uint16_t + */ +#define emberAfFillCommandIasAceClusterGetZoneIdMapResponse(section0, \ + section1, \ + section2, \ + section3, \ + section4, \ + section5, \ + section6, \ + section7, \ + section8, \ + section9, \ + section10, \ + section11, \ + section12, \ + section13, \ + section14, \ + section15) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID, \ + "vvvvvvvvvvvvvvvv", \ + section0, \ + section1, \ + section2, \ + section3, \ + section4, \ + section5, \ + section6, \ + section7, \ + section8, \ + section9, \ + section10, \ + section11, \ + section12, \ + section13, \ + section14, \ + section15); + + +/** @brief Command description for GetZoneInformationResponse + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneInformationResponse + * @param zoneId uint8_t + * @param zoneType uint16_t + * @param ieeeAddress uint8_t* + * @param zoneLabel uint8_t* + */ +#define emberAfFillCommandIasAceClusterGetZoneInformationResponse(zoneId, \ + zoneType, \ + ieeeAddress, \ + zoneLabel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_INFORMATION_RESPONSE_COMMAND_ID, \ + "uv8s", \ + zoneId, \ + zoneType, \ + ieeeAddress, \ + zoneLabel); + + +/** @brief This command updates ACE clients in the system of changes to zone status recorded by the ACE server (e.g., IAS CIE device). + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: ZoneStatusChanged + * @param zoneId uint8_t + * @param zoneStatus uint16_t + * @param audibleNotification uint8_t + * @param zoneLabel uint8_t* + */ +#define emberAfFillCommandIasAceClusterZoneStatusChanged(zoneId, \ + zoneStatus, \ + audibleNotification, \ + zoneLabel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ZONE_STATUS_CHANGED_COMMAND_ID, \ + "uvus", \ + zoneId, \ + zoneStatus, \ + audibleNotification, \ + zoneLabel); + + +/** @brief This command updates ACE clients in the system of changes to panel status recorded by the ACE server (e.g., IAS CIE device). + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: PanelStatusChanged + * @param panelStatus uint8_t + * @param secondsRemaining uint8_t + * @param audibleNotification uint8_t + * @param alarmStatus uint8_t + */ +#define emberAfFillCommandIasAceClusterPanelStatusChanged(panelStatus, \ + secondsRemaining, \ + audibleNotification, \ + alarmStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_PANEL_STATUS_CHANGED_COMMAND_ID, \ + "uuuu", \ + panelStatus, \ + secondsRemaining, \ + audibleNotification, \ + alarmStatus); + + +/** @brief Command updates requesting IAS ACE clients in the system of changes to the security panel status recorded by the ACE server. + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetPanelStatusResponse + * @param panelStatus uint8_t + * @param secondsRemaining uint8_t + * @param audibleNotification uint8_t + * @param alarmStatus uint8_t + */ +#define emberAfFillCommandIasAceClusterGetPanelStatusResponse(panelStatus, \ + secondsRemaining, \ + audibleNotification, \ + alarmStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID, \ + "uuuu", \ + panelStatus, \ + secondsRemaining, \ + audibleNotification, \ + alarmStatus); + + +/** @brief Sets the list of bypassed zones on the IAS ACE client + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: SetBypassedZoneList + * @param numberOfZones uint8_t + * @param zoneIds uint8_t* + * @param zoneIdsLen uint16_t + */ +#define emberAfFillCommandIasAceClusterSetBypassedZoneList(numberOfZones, \ + zoneIds, \ + zoneIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID, \ + "ub", \ + numberOfZones, \ + zoneIds, \ + zoneIdsLen); + + +/** @brief Provides the response of the security panel to the request from the IAS ACE client to bypass zones via a Bypass command. + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: BypassResponse + * @param numberOfZones uint8_t + * @param bypassResult uint8_t* + * @param bypassResultLen uint16_t + */ +#define emberAfFillCommandIasAceClusterBypassResponse(numberOfZones, \ + bypassResult, \ + bypassResultLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_BYPASS_RESPONSE_COMMAND_ID, \ + "ub", \ + numberOfZones, \ + bypassResult, \ + bypassResultLen); + + +/** @brief This command updates requesting IAS ACE clients in the system of changes to the IAS Zone server statuses recorded by the ACE server (e.g., IAS CIE device). + * + * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. + * Command: GetZoneStatusResponse + * @param zoneStatusComplete uint8_t + * @param numberOfZones uint8_t + * @param zoneStatusResult uint8_t* + * @param zoneStatusResultLen uint16_t + */ +#define emberAfFillCommandIasAceClusterGetZoneStatusResponse(zoneStatusComplete, \ + numberOfZones, \ + zoneStatusResult, \ + zoneStatusResultLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID, \ + "uub", \ + zoneStatusComplete, \ + numberOfZones, \ + zoneStatusResult, \ + zoneStatusResultLen); + + +/** @} END IAS ACE Commands */ + + +/** @name IAS WD Commands */ +// @{ +/** @brief Command description for StartWarning + * + * Cluster: IAS WD, Attributes and commands for IAS Warning Devices. + * Command: StartWarning + * @param warningInfo uint8_t + * @param warningDuration uint16_t + * @param strobeDutyCycle uint8_t + * @param strobeLevel uint8_t + */ +#define emberAfFillCommandIasWdClusterStartWarning(warningInfo, \ + warningDuration, \ + strobeDutyCycle, \ + strobeLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_WD_CLUSTER_ID, \ + ZCL_START_WARNING_COMMAND_ID, \ + "uvuu", \ + warningInfo, \ + warningDuration, \ + strobeDutyCycle, \ + strobeLevel); + + +/** @brief Command description for Squawk + * + * Cluster: IAS WD, Attributes and commands for IAS Warning Devices. + * Command: Squawk + * @param squawkInfo uint8_t + */ +#define emberAfFillCommandIasWdClusterSquawk(squawkInfo) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_IAS_WD_CLUSTER_ID, \ + ZCL_SQUAWK_COMMAND_ID, \ + "u", \ + squawkInfo); + + +/** @} END IAS WD Commands */ + + +/** @name Generic Tunnel Commands */ +// @{ +/** @brief This command is generated when an application wishes to find the ZigBee address (node, endpoint) of the Generic Tunnel server cluster with a given ProtocolAddress attribute. The command is typically multicast to a group of inter-communicating Generic Tunnel clusters + * + * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. + * Command: MatchProtocolAddress + * @param protocolAddress uint8_t* + */ +#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddress(protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, \ + "s", \ + protocolAddress); + + +/** @brief This command is generated upon receipt of a Match Protocol Address command to indicate that the Protocol Address was successfully matched. + * + * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. + * Command: MatchProtocolAddressResponse + * @param deviceIeeeAddress uint8_t* + * @param protocolAddress uint8_t* + */ +#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddressResponse(deviceIeeeAddress, \ + protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_MATCH_PROTOCOL_ADDRESS_RESPONSE_COMMAND_ID, \ + "8s", \ + deviceIeeeAddress, \ + protocolAddress); + + +/** @brief This command is typically sent upon startup, and whenever the ProtocolAddress attribute changes. It is typically multicast to a group of inter-communicating Generic Tunnel clusters. + * + * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. + * Command: AdvertiseProtocolAddress + * @param protocolAddress uint8_t* + */ +#define emberAfFillCommandGenericTunnelClusterAdvertiseProtocolAddress(protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, \ + "s", \ + protocolAddress); + + +/** @} END Generic Tunnel Commands */ + + +/** @name BACnet Protocol Tunnel Commands */ +// @{ +/** @brief This command is generated when a BACnet network layer wishes to transfer a BACnet NPDU across a ZigBee tunnel to another BACnet network layer. + * + * Cluster: BACnet Protocol Tunnel, Commands and attributes required to tunnel the BACnet protocol. + * Command: TransferNpdu + * @param npdu uint8_t* + * @param npduLen uint16_t + */ +#define emberAfFillCommandBacnetProtocolTunnelClusterTransferNpdu(npdu, \ + npduLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_TRANSFER_NPDU_COMMAND_ID, \ + "b", \ + npdu, \ + npduLen); + + +/** @} END BACnet Protocol Tunnel Commands */ + + +/** @name 11073 Protocol Tunnel Commands */ +// @{ +/** @brief This command is generated when an 11073 network layer wishes to transfer an 11073 APDU across a ZigBee tunnel to another 11073 network layer. + * + * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. + * Command: TransferAPDU + * @param apdu uint8_t* + */ +#define emberAfFillCommand11073ProtocolTunnelClusterTransferAPDU(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_TRANSFER_A_P_D_U_COMMAND_ID, \ + "s", \ + apdu); + + +/** @brief This command is generated when an Health Care client wishes to connect to a Health Care server for the purposes of transmitting 11073 APDUs across the 11073 tunnel. + * + * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. + * Command: ConnectRequest + * @param connectControl uint8_t + * @param idleTimeout uint16_t + * @param managerTarget uint8_t* + * @param managerEndpoint uint8_t + */ +#define emberAfFillCommand11073ProtocolTunnelClusterConnectRequest(connectControl, \ + idleTimeout, \ + managerTarget, \ + managerEndpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_CONNECT_REQUEST_COMMAND_ID, \ + "uv8u", \ + connectControl, \ + idleTimeout, \ + managerTarget, \ + managerEndpoint); + + +/** @brief This command is generated when an Health Care client wishes to disconnect from a Health Care server. + * + * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. + * Command: DisconnectRequest + * @param managerIEEEAddress uint8_t* + */ +#define emberAfFillCommand11073ProtocolTunnelClusterDisconnectRequest(managerIEEEAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_DISCONNECT_REQUEST_COMMAND_ID, \ + "8", \ + managerIEEEAddress); + + +/** @brief Generated in response to requests related to connection or any event that causes the tunnel to become disconnected. + * + * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. + * Command: ConnectStatusNotification + * @param connectStatus uint8_t + */ +#define emberAfFillCommand11073ProtocolTunnelClusterConnectStatusNotification(connectStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, \ + "u", \ + connectStatus); + + +/** @} END 11073 Protocol Tunnel Commands */ + + +/** @name ISO 7816 Protocol Tunnel Commands */ +// @{ +/** @brief Command description for TransferApdu + * + * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. + * Command: TransferApdu + * @param apdu uint8_t* + */ +#define emberAfFillCommandIso7816ProtocolTunnelClusterServerToClientTransferApdu(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_TRANSFER_APDU_COMMAND_ID, \ + "s", \ + apdu); + + +/** @brief Command description for TransferApdu + * + * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. + * Command: TransferApdu + * @param apdu uint8_t* + */ +#define emberAfFillCommandIso7816ProtocolTunnelClusterClientToServerTransferApdu(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_TRANSFER_APDU_COMMAND_ID, \ + "s", \ + apdu); + + +/** @brief Command description for InsertSmartCard + * + * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. + * Command: InsertSmartCard + */ +#define emberAfFillCommandIso7816ProtocolTunnelClusterInsertSmartCard() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_INSERT_SMART_CARD_COMMAND_ID, \ + ""); + + +/** @brief Command description for ExtractSmartCard + * + * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. + * Command: ExtractSmartCard + */ +#define emberAfFillCommandIso7816ProtocolTunnelClusterExtractSmartCard() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ + ZCL_EXTRACT_SMART_CARD_COMMAND_ID, \ + ""); + + +/** @} END ISO 7816 Protocol Tunnel Commands */ + + +/** @name Price Commands */ +// @{ +/** @brief The PublishPrice command is generated in response to receiving a Get Current Price command, in response to a Get Scheduled Prices command, and when an update to the pricing information is available from the commodity provider, either before or when a TOU price becomes active. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishPrice + * @param providerId uint32_t + * @param rateLabel uint8_t* + * @param issuerEventId uint32_t + * @param currentTime uint32_t + * @param unitOfMeasure uint8_t + * @param currency uint16_t + * @param priceTrailingDigitAndPriceTier uint8_t + * @param numberOfPriceTiersAndRegisterTier uint8_t + * @param startTime uint32_t + * @param durationInMinutes uint16_t + * @param price uint32_t + * @param priceRatio uint8_t + * @param generationPrice uint32_t + * @param generationPriceRatio uint8_t + * @param alternateCostDelivered uint32_t + * @param alternateCostUnit uint8_t + * @param alternateCostTrailingDigit uint8_t + * @param numberOfBlockThresholds uint8_t + * @param priceControl uint8_t + * @param numberOfGenerationTiers uint8_t + * @param generationTier uint8_t + * @param extendedNumberOfPriceTiers uint8_t + * @param extendedPriceTier uint8_t + * @param extendedRegisterTier uint8_t + */ +#define emberAfFillCommandPriceClusterPublishPrice(providerId, \ + rateLabel, \ + issuerEventId, \ + currentTime, \ + unitOfMeasure, \ + currency, \ + priceTrailingDigitAndPriceTier, \ + numberOfPriceTiersAndRegisterTier, \ + startTime, \ + durationInMinutes, \ + price, \ + priceRatio, \ + generationPrice, \ + generationPriceRatio, \ + alternateCostDelivered, \ + alternateCostUnit, \ + alternateCostTrailingDigit, \ + numberOfBlockThresholds, \ + priceControl, \ + numberOfGenerationTiers, \ + generationTier, \ + extendedNumberOfPriceTiers, \ + extendedPriceTier, \ + extendedRegisterTier) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_PRICE_COMMAND_ID, \ + "wswwuvuuwvwuwuwuuuuuuuuu", \ + providerId, \ + rateLabel, \ + issuerEventId, \ + currentTime, \ + unitOfMeasure, \ + currency, \ + priceTrailingDigitAndPriceTier, \ + numberOfPriceTiersAndRegisterTier, \ + startTime, \ + durationInMinutes, \ + price, \ + priceRatio, \ + generationPrice, \ + generationPriceRatio, \ + alternateCostDelivered, \ + alternateCostUnit, \ + alternateCostTrailingDigit, \ + numberOfBlockThresholds, \ + priceControl, \ + numberOfGenerationTiers, \ + generationTier, \ + extendedNumberOfPriceTiers, \ + extendedPriceTier, \ + extendedRegisterTier); + + +/** @brief The PublishBlockPeriod command is generated in response to receiving a GetBlockPeriod(s) command or when an update to the block tariff schedule is available from the commodity provider. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishBlockPeriod + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param blockPeriodStartTime uint32_t + * @param blockPeriodDuration uint32_t + * @param blockPeriodControl uint8_t + * @param blockPeriodDurationType uint8_t + * @param tariffType uint8_t + * @param tariffResolutionPeriod uint8_t + */ +#define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, \ + issuerEventId, \ + blockPeriodStartTime, \ + blockPeriodDuration, \ + blockPeriodControl, \ + blockPeriodDurationType, \ + tariffType, \ + tariffResolutionPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, \ + "wwwxuuuu", \ + providerId, \ + issuerEventId, \ + blockPeriodStartTime, \ + blockPeriodDuration, \ + blockPeriodControl, \ + blockPeriodDurationType, \ + tariffType, \ + tariffResolutionPeriod); + + +/** @brief The PublishConversionFactor command is sent in response to a GetConversionFactor command or if a new Conversion factor is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishConversionFactor + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param conversionFactor uint32_t + * @param conversionFactorTrailingDigit uint8_t + */ +#define emberAfFillCommandPriceClusterPublishConversionFactor(issuerEventId, \ + startTime, \ + conversionFactor, \ + conversionFactorTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, \ + "wwwu", \ + issuerEventId, \ + startTime, \ + conversionFactor, \ + conversionFactorTrailingDigit); + + +/** @brief The PublishCalorificValue command is sent in response to a GetCalorificValue command or if a new calorific value is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishCalorificValue + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param calorificValue uint32_t + * @param calorificValueUnit uint8_t + * @param calorificValueTrailingDigit uint8_t + */ +#define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, \ + startTime, \ + calorificValue, \ + calorificValueUnit, \ + calorificValueTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, \ + "wwwuu", \ + issuerEventId, \ + startTime, \ + calorificValue, \ + calorificValueUnit, \ + calorificValueTrailingDigit); + + +/** @brief The PublishTariffInformation command is sent in response to a GetTariffInformation command or if new tariff information is available (including price matrix and block thresholds). + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishTariffInformation + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerTariffId uint32_t + * @param startTime uint32_t + * @param tariffTypeChargingScheme uint8_t + * @param tariffLabel uint8_t* + * @param numberOfPriceTiersInUse uint8_t + * @param numberOfBlockThresholdsInUse uint8_t + * @param unitOfMeasure uint8_t + * @param currency uint16_t + * @param priceTrailingDigit uint8_t + * @param standingCharge uint32_t + * @param tierBlockMode uint8_t + * @param blockThresholdMultiplier uint32_t + * @param blockThresholdDivisor uint32_t + */ +#define emberAfFillCommandPriceClusterPublishTariffInformation(providerId, \ + issuerEventId, \ + issuerTariffId, \ + startTime, \ + tariffTypeChargingScheme, \ + tariffLabel, \ + numberOfPriceTiersInUse, \ + numberOfBlockThresholdsInUse, \ + unitOfMeasure, \ + currency, \ + priceTrailingDigit, \ + standingCharge, \ + tierBlockMode, \ + blockThresholdMultiplier, \ + blockThresholdDivisor) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, \ + "wwwwusuuuvuwuxx", \ + providerId, \ + issuerEventId, \ + issuerTariffId, \ + startTime, \ + tariffTypeChargingScheme, \ + tariffLabel, \ + numberOfPriceTiersInUse, \ + numberOfBlockThresholdsInUse, \ + unitOfMeasure, \ + currency, \ + priceTrailingDigit, \ + standingCharge, \ + tierBlockMode, \ + blockThresholdMultiplier, \ + blockThresholdDivisor); + + +/** @brief PublishPriceMatrix command is used to publish the Block Price Information Set (up to 15 tiers x 15 blocks) and the Extended Price Information Set (up to 48 tiers). The PublishPriceMatrix command is sent in response to a GetPriceMatrix command. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishPriceMatrix + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param issuerTariffId uint32_t + * @param commandIndex uint8_t + * @param numberOfCommands uint8_t + * @param subPayloadControl uint8_t + * @param payload uint8_t* + * @param payloadLen uint16_t + */ +#define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, \ + issuerEventId, \ + startTime, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + subPayloadControl, \ + payload, \ + payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, \ + "wwwwuuub", \ + providerId, \ + issuerEventId, \ + startTime, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + subPayloadControl, \ + payload, \ + payloadLen); + + +/** @brief The PublishBlockThreshold command is sent in response to a GetBlockThreshold command. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishBlockThresholds + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param issuerTariffId uint32_t + * @param commandIndex uint8_t + * @param numberOfCommands uint8_t + * @param subPayloadControl uint8_t + * @param payload uint8_t* + * @param payloadLen uint16_t + */ +#define emberAfFillCommandPriceClusterPublishBlockThresholds(providerId, \ + issuerEventId, \ + startTime, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + subPayloadControl, \ + payload, \ + payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, \ + "wwwwuuub", \ + providerId, \ + issuerEventId, \ + startTime, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + subPayloadControl, \ + payload, \ + payloadLen); + + +/** @brief The PublishCO2Value command is sent in response to a GetCO2Value command or if a new CO2 conversion factor is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishCO2Value + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param tariffType uint8_t + * @param cO2Value uint32_t + * @param cO2ValueUnit uint8_t + * @param cO2ValueTrailingDigit uint8_t + */ +#define emberAfFillCommandPriceClusterPublishCO2Value(providerId, \ + issuerEventId, \ + startTime, \ + tariffType, \ + cO2Value, \ + cO2ValueUnit, \ + cO2ValueTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID, \ + "wwwuwuu", \ + providerId, \ + issuerEventId, \ + startTime, \ + tariffType, \ + cO2Value, \ + cO2ValueUnit, \ + cO2ValueTrailingDigit); + + +/** @brief The PublishTierLabels command is generated in response to receiving a GetTierLabels command or when there is a tier label change. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishTierLabels + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerTariffId uint32_t + * @param commandIndex uint8_t + * @param numberOfCommands uint8_t + * @param numberOfLabels uint8_t + * @param tierLabelsPayload uint8_t* + * @param tierLabelsPayloadLen uint16_t + */ +#define emberAfFillCommandPriceClusterPublishTierLabels(providerId, \ + issuerEventId, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + numberOfLabels, \ + tierLabelsPayload, \ + tierLabelsPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, \ + "wwwuuub", \ + providerId, \ + issuerEventId, \ + issuerTariffId, \ + commandIndex, \ + numberOfCommands, \ + numberOfLabels, \ + tierLabelsPayload, \ + tierLabelsPayloadLen); + + +/** @brief The PublishBillingPeriod command is generated in response to receiving a GetBillingPeriod(s) command or when an update to the Billing schedule is available from the commodity Supplier. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishBillingPeriod + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param billingPeriodStartTime uint32_t + * @param billingPeriodDuration uint32_t + * @param billingPeriodDurationType uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, \ + issuerEventId, \ + billingPeriodStartTime, \ + billingPeriodDuration, \ + billingPeriodDurationType, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, \ + "wwwxuu", \ + providerId, \ + issuerEventId, \ + billingPeriodStartTime, \ + billingPeriodDuration, \ + billingPeriodDurationType, \ + tariffType); + + +/** @brief The PublishConsolidatedBill command is used to make consolidated billing information of previous billing periods available to other end devices. This command is issued in response to a GetConsolidatedBill command or if new billing information is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishConsolidatedBill + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param billingPeriodStartTime uint32_t + * @param billingPeriodDuration uint32_t + * @param billingPeriodDurationType uint8_t + * @param tariffType uint8_t + * @param consolidatedBill uint32_t + * @param currency uint16_t + * @param billTrailingDigit uint8_t + */ +#define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, \ + issuerEventId, \ + billingPeriodStartTime, \ + billingPeriodDuration, \ + billingPeriodDurationType, \ + tariffType, \ + consolidatedBill, \ + currency, \ + billTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, \ + "wwwxuuwvu", \ + providerId, \ + issuerEventId, \ + billingPeriodStartTime, \ + billingPeriodDuration, \ + billingPeriodDurationType, \ + tariffType, \ + consolidatedBill, \ + currency, \ + billTrailingDigit); + + +/** @brief The PublishCPPEvent command is sent from an ESI to its price clients to notify them of a Critical Peak Pricing event. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishCppEvent + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param durationInMinutes uint16_t + * @param tariffType uint8_t + * @param cppPriceTier uint8_t + * @param cppAuth uint8_t + */ +#define emberAfFillCommandPriceClusterPublishCppEvent(providerId, \ + issuerEventId, \ + startTime, \ + durationInMinutes, \ + tariffType, \ + cppPriceTier, \ + cppAuth) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, \ + "wwwvuuu", \ + providerId, \ + issuerEventId, \ + startTime, \ + durationInMinutes, \ + tariffType, \ + cppPriceTier, \ + cppAuth); + + +/** @brief The PublishCreditPayment command is used to update the credit payment information is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishCreditPayment + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param creditPaymentDueDate uint32_t + * @param creditPaymentOverDueAmount uint32_t + * @param creditPaymentStatus uint8_t + * @param creditPayment uint32_t + * @param creditPaymentDate uint32_t + * @param creditPaymentRef uint8_t* + */ +#define emberAfFillCommandPriceClusterPublishCreditPayment(providerId, \ + issuerEventId, \ + creditPaymentDueDate, \ + creditPaymentOverDueAmount, \ + creditPaymentStatus, \ + creditPayment, \ + creditPaymentDate, \ + creditPaymentRef) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, \ + "wwwwuwws", \ + providerId, \ + issuerEventId, \ + creditPaymentDueDate, \ + creditPaymentOverDueAmount, \ + creditPaymentStatus, \ + creditPayment, \ + creditPaymentDate, \ + creditPaymentRef); + + +/** @brief The PublishCurrencyConversion command is sent in response to a GetCurrencyConversion command or when a new currency becomes available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PublishCurrencyConversion + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param oldCurrency uint16_t + * @param newCurrency uint16_t + * @param conversionFactor uint32_t + * @param conversionFactorTrailingDigit uint8_t + * @param currencyChangeControlFlags uint32_t + */ +#define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, \ + issuerEventId, \ + startTime, \ + oldCurrency, \ + newCurrency, \ + conversionFactor, \ + conversionFactorTrailingDigit, \ + currencyChangeControlFlags) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, \ + "wwwvvwuw", \ + providerId, \ + issuerEventId, \ + startTime, \ + oldCurrency, \ + newCurrency, \ + conversionFactor, \ + conversionFactorTrailingDigit, \ + currencyChangeControlFlags); + + +/** @brief The CancelTariff command indicates that all data associated with a particular tariff instance should be discarded. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: CancelTariff + * @param providerId uint32_t + * @param issuerTariffId uint32_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterCancelTariff(providerId, \ + issuerTariffId, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_CANCEL_TARIFF_COMMAND_ID, \ + "wwu", \ + providerId, \ + issuerTariffId, \ + tariffType); + + +/** @brief The GetCurrentPrice command initiates a PublishPrice command for the current time. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetCurrentPrice + * @param commandOptions uint8_t + */ +#define emberAfFillCommandPriceClusterGetCurrentPrice(commandOptions) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CURRENT_PRICE_COMMAND_ID, \ + "u", \ + commandOptions); + + +/** @brief The GetScheduledPrices command initiates a PublishPrice command for available price events. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetScheduledPrices + * @param startTime uint32_t + * @param numberOfEvents uint8_t + */ +#define emberAfFillCommandPriceClusterGetScheduledPrices(startTime, \ + numberOfEvents) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_SCHEDULED_PRICES_COMMAND_ID, \ + "wu", \ + startTime, \ + numberOfEvents); + + +/** @brief The PriceAcknowledgement command described provides the ability to acknowledge a previously sent PublishPrice command. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: PriceAcknowledgement + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param priceAckTime uint32_t + * @param control uint8_t + */ +#define emberAfFillCommandPriceClusterPriceAcknowledgement(providerId, \ + issuerEventId, \ + priceAckTime, \ + control) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID, \ + "wwwu", \ + providerId, \ + issuerEventId, \ + priceAckTime, \ + control); + + +/** @brief The GetBlockPeriods command initiates a PublishBlockPeriod command for the currently scheduled block periods. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetBlockPeriods + * @param startTime uint32_t + * @param numberOfEvents uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterGetBlockPeriods(startTime, \ + numberOfEvents, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BLOCK_PERIODS_COMMAND_ID, \ + "wuu", \ + startTime, \ + numberOfEvents, \ + tariffType); + + +/** @brief The GetConversionFactor command initiates a PublishConversionFactor command for the scheduled conversion factor updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetConversionFactor + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + */ +#define emberAfFillCommandPriceClusterGetConversionFactor(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CONVERSION_FACTOR_COMMAND_ID, \ + "wwu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands); + + +/** @brief The GetCalorificValue command initiates a PublishCalorificValue command for the scheduled conversion factor updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetCalorificValue + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + */ +#define emberAfFillCommandPriceClusterGetCalorificValue(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CALORIFIC_VALUE_COMMAND_ID, \ + "wwu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands); + + +/** @brief The GetTariffInformation command initiates a PublishTariffInformation command for the scheduled tariff updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetTariffInformation + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterGetTariffInformation(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TARIFF_INFORMATION_COMMAND_ID, \ + "wwuu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType); + + +/** @brief The GetPriceMatrix command initiates a PublishPriceMatrix command for the scheduled Price Matrix updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetPriceMatrix + * @param issuerTariffId uint32_t + */ +#define emberAfFillCommandPriceClusterGetPriceMatrix(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_PRICE_MATRIX_COMMAND_ID, \ + "w", \ + issuerTariffId); + + +/** @brief The GetBlockThresholds command initiates a PublishBlockThreshold command for the scheduled Block Threshold updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetBlockThresholds + * @param issuerTariffId uint32_t + */ +#define emberAfFillCommandPriceClusterGetBlockThresholds(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID, \ + "w", \ + issuerTariffId); + + +/** @brief The GetCO2Value command initiates a PublishCO2Value command for the scheduled CO2 conversion factor updates. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetCO2Value + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterGetCO2Value(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_C_O2_VALUE_COMMAND_ID, \ + "wwuu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType); + + +/** @brief The GetTierLabels command allows a client to retrieve the tier labels associated with a given tariff; this command initiates a PublishTierLabels command from the server. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetTierLabels + * @param issuerTariffId uint32_t + */ +#define emberAfFillCommandPriceClusterGetTierLabels(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TIER_LABELS_COMMAND_ID, \ + "w", \ + issuerTariffId); + + +/** @brief The GetBillingPeriod command initiates one or more PublishBillingPeriod commands for the currently scheduled billing periods. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetBillingPeriod + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterGetBillingPeriod(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BILLING_PERIOD_COMMAND_ID, \ + "wwuu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType); + + +/** @brief The GetConsolidatedBill command initiates one or more PublishConsolidatedBill commands with the requested billing information. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetConsolidatedBill + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCommands uint8_t + * @param tariffType uint8_t + */ +#define emberAfFillCommandPriceClusterGetConsolidatedBill(earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID, \ + "wwuu", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCommands, \ + tariffType); + + +/** @brief The CPPEventResponse command is sent from a Client (IHD) to the ESI to notify it of a Critical Peak Pricing event authorization. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: CppEventResponse + * @param issuerEventId uint32_t + * @param cppAuth uint8_t + */ +#define emberAfFillCommandPriceClusterCppEventResponse(issuerEventId, \ + cppAuth) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_CPP_EVENT_RESPONSE_COMMAND_ID, \ + "wu", \ + issuerEventId, \ + cppAuth); + + +/** @brief The GetCreditPayment command initiates PublishCreditPayment commands for the requested credit payment information. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetCreditPayment + * @param latestEndTime uint32_t + * @param numberOfRecords uint8_t + */ +#define emberAfFillCommandPriceClusterGetCreditPayment(latestEndTime, \ + numberOfRecords) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CREDIT_PAYMENT_COMMAND_ID, \ + "wu", \ + latestEndTime, \ + numberOfRecords); + + +/** @brief The GetCurrencyConversionCommand command initiates a PublishCurrencyConversion command for the currency conversion factor updates. A server shall be capable of storing both the old and the new currencies. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetCurrencyConversionCommand + */ +#define emberAfFillCommandPriceClusterGetCurrencyConversionCommand() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, \ + ""); + + +/** @brief The GetTariffCancellation command initiates the return of the last CancelTariff command held on the associated server. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. + * Command: GetTariffCancellation + */ +#define emberAfFillCommandPriceClusterGetTariffCancellation() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, \ + ""); + + +/** @} END Price Commands */ + + +/** @name Demand Response and Load Control Commands */ +// @{ +/** @brief Command description for LoadControlEvent + * + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. + * Command: LoadControlEvent + * @param issuerEventId uint32_t + * @param deviceClass uint16_t + * @param utilityEnrollmentGroup uint8_t + * @param startTime uint32_t + * @param durationInMinutes uint16_t + * @param criticalityLevel uint8_t + * @param coolingTemperatureOffset uint8_t + * @param heatingTemperatureOffset uint8_t + * @param coolingTemperatureSetPoint int16_t + * @param heatingTemperatureSetPoint int16_t + * @param averageLoadAdjustmentPercentage int8_t + * @param dutyCycle uint8_t + * @param eventControl uint8_t + */ +#define emberAfFillCommandDemandResponseLoadControlClusterLoadControlEvent(issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + startTime, \ + durationInMinutes, \ + criticalityLevel, \ + coolingTemperatureOffset, \ + heatingTemperatureOffset, \ + coolingTemperatureSetPoint, \ + heatingTemperatureSetPoint, \ + averageLoadAdjustmentPercentage, \ + dutyCycle, \ + eventControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, \ + "wvuwvuuuvvuuu", \ + issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + startTime, \ + durationInMinutes, \ + criticalityLevel, \ + coolingTemperatureOffset, \ + heatingTemperatureOffset, \ + coolingTemperatureSetPoint, \ + heatingTemperatureSetPoint, \ + averageLoadAdjustmentPercentage, \ + dutyCycle, \ + eventControl); + + +/** @brief Command description for CancelLoadControlEvent + * + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. + * Command: CancelLoadControlEvent + * @param issuerEventId uint32_t + * @param deviceClass uint16_t + * @param utilityEnrollmentGroup uint8_t + * @param cancelControl uint8_t + * @param effectiveTime uint32_t + */ +#define emberAfFillCommandDemandResponseLoadControlClusterCancelLoadControlEvent(issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + cancelControl, \ + effectiveTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, \ + "wvuuw", \ + issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + cancelControl, \ + effectiveTime); + + +/** @brief Command description for CancelAllLoadControlEvents + * + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. + * Command: CancelAllLoadControlEvents + * @param cancelControl uint8_t + */ +#define emberAfFillCommandDemandResponseLoadControlClusterCancelAllLoadControlEvents(cancelControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, \ + "u", \ + cancelControl); + + +/** @brief Command description for ReportEventStatus + * + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. + * Command: ReportEventStatus + * @param issuerEventId uint32_t + * @param eventStatus uint8_t + * @param eventStatusTime uint32_t + * @param criticalityLevelApplied uint8_t + * @param coolingTemperatureSetPointApplied uint16_t + * @param heatingTemperatureSetPointApplied uint16_t + * @param averageLoadAdjustmentPercentageApplied int8_t + * @param dutyCycleApplied uint8_t + * @param eventControl uint8_t + * @param signatureType uint8_t + * @param signature uint8_t* + */ +#define emberAfFillCommandDemandResponseLoadControlClusterReportEventStatus(issuerEventId, \ + eventStatus, \ + eventStatusTime, \ + criticalityLevelApplied, \ + coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, \ + averageLoadAdjustmentPercentageApplied, \ + dutyCycleApplied, \ + eventControl, \ + signatureType, \ + signature) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_REPORT_EVENT_STATUS_COMMAND_ID, \ + "wuwuvvuuuub", \ + issuerEventId, \ + eventStatus, \ + eventStatusTime, \ + criticalityLevelApplied, \ + coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, \ + averageLoadAdjustmentPercentageApplied, \ + dutyCycleApplied, \ + eventControl, \ + signatureType, \ + signature, \ + 42); + + +/** @brief Command description for GetScheduledEvents + * + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. + * Command: GetScheduledEvents + * @param startTime uint32_t + * @param numberOfEvents uint8_t + * @param issuerEventId uint32_t + */ +#define emberAfFillCommandDemandResponseLoadControlClusterGetScheduledEvents(startTime, \ + numberOfEvents, \ + issuerEventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_GET_SCHEDULED_EVENTS_COMMAND_ID, \ + "wuw", \ + startTime, \ + numberOfEvents, \ + issuerEventId); + + +/** @} END Demand Response and Load Control Commands */ + + +/** @name Simple Metering Commands */ +// @{ +/** @brief This command is generated when the Client command GetProfile is received. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetProfileResponse + * @param endTime uint32_t + * @param status uint8_t + * @param profileIntervalPeriod uint8_t + * @param numberOfPeriodsDelivered uint8_t + * @param intervals uint8_t* + * @param intervalsLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetProfileResponse(endTime, \ + status, \ + profileIntervalPeriod, \ + numberOfPeriodsDelivered, \ + intervals, \ + intervalsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, \ + "wuuub", \ + endTime, \ + status, \ + profileIntervalPeriod, \ + numberOfPeriodsDelivered, \ + intervals, \ + intervalsLen); + + +/** @brief This command is used to request the ESI to mirror Metering Device data. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: RequestMirror + */ +#define emberAfFillCommandSimpleMeteringClusterRequestMirror() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_MIRROR_COMMAND_ID, \ + ""); + + +/** @brief This command is used to request the ESI to remove its mirror of Metering Device data. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: RemoveMirror + */ +#define emberAfFillCommandSimpleMeteringClusterRemoveMirror() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REMOVE_MIRROR_COMMAND_ID, \ + ""); + + +/** @brief This command is generated when the client command Request Fast Poll Mode is received. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: RequestFastPollModeResponse + * @param appliedUpdatePeriod uint8_t + * @param fastPollModeEndtime uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, \ + fastPollModeEndtime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, \ + "uw", \ + appliedUpdatePeriod, \ + fastPollModeEndtime); + + +/** @brief This command is generated in response to a ScheduleSnapshot command, and is sent to confirm whether the requested snapshot schedule has been set up. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ScheduleSnapshotResponse + * @param issuerEventId uint32_t + * @param snapshotResponsePayload uint8_t* + * @param snapshotResponsePayloadLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshotResponse(issuerEventId, \ + snapshotResponsePayload, \ + snapshotResponsePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, \ + "wb", \ + issuerEventId, \ + snapshotResponsePayload, \ + snapshotResponsePayloadLen); + + +/** @brief This command is generated in response to a TakeSnapshot command, and is sent to confirm whether the requested snapshot has been accepted and successfully taken. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: TakeSnapshotResponse + * @param snapshotId uint32_t + * @param snapshotConfirmation uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterTakeSnapshotResponse(snapshotId, \ + snapshotConfirmation) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, \ + "wu", \ + snapshotId, \ + snapshotConfirmation); + + +/** @brief This command is generated in response to a GetSnapshot command. It is used to return a single snapshot to the client. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: PublishSnapshot + * @param snapshotId uint32_t + * @param snapshotTime uint32_t + * @param totalSnapshotsFound uint8_t + * @param commandIndex uint8_t + * @param totalCommands uint8_t + * @param snapshotCause uint32_t + * @param snapshotPayloadType uint8_t + * @param snapshotPayload uint8_t* + * @param snapshotPayloadLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterPublishSnapshot(snapshotId, \ + snapshotTime, \ + totalSnapshotsFound, \ + commandIndex, \ + totalCommands, \ + snapshotCause, \ + snapshotPayloadType, \ + snapshotPayload, \ + snapshotPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, \ + "wwuuuwub", \ + snapshotId, \ + snapshotTime, \ + totalSnapshotsFound, \ + commandIndex, \ + totalCommands, \ + snapshotCause, \ + snapshotPayloadType, \ + snapshotPayload, \ + snapshotPayloadLen); + + +/** @brief This command is used to send the requested sample data to the client. It is generated in response to a GetSampledData command. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetSampledDataResponse + * @param sampleId uint16_t + * @param sampleStartTime uint32_t + * @param sampleType uint8_t + * @param sampleRequestInterval uint16_t + * @param numberOfSamples uint16_t + * @param samples uint8_t* + * @param samplesLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetSampledDataResponse(sampleId, \ + sampleStartTime, \ + sampleType, \ + sampleRequestInterval, \ + numberOfSamples, \ + samples, \ + samplesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, \ + "vwuvvb", \ + sampleId, \ + sampleStartTime, \ + sampleType, \ + sampleRequestInterval, \ + numberOfSamples, \ + samples, \ + samplesLen); + + +/** @brief ConfigureMirror is sent to the mirror once the mirror has been created. The command deals with the operational configuration of the Mirror. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ConfigureMirror + * @param issuerEventId uint32_t + * @param reportingInterval uint32_t + * @param mirrorNotificationReporting uint8_t + * @param notificationScheme uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterConfigureMirror(issuerEventId, \ + reportingInterval, \ + mirrorNotificationReporting, \ + notificationScheme) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_MIRROR_COMMAND_ID, \ + "wxuu", \ + issuerEventId, \ + reportingInterval, \ + mirrorNotificationReporting, \ + notificationScheme); + + +/** @brief The ConfigureNotificationScheme is sent to the mirror once the mirror has been created. The command deals with the operational configuration of the Mirror and the device that reports to the mirror. No default schemes are allowed to be overwritten. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ConfigureNotificationScheme + * @param issuerEventId uint32_t + * @param notificationScheme uint8_t + * @param notificationFlagOrder uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationScheme(issuerEventId, \ + notificationScheme, \ + notificationFlagOrder) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, \ + "wuw", \ + issuerEventId, \ + notificationScheme, \ + notificationFlagOrder); + + +/** @brief The ConfigureNotificationFlags command is used to set the commands relating to the bit value for each NotificationFlags attribute that the scheme is proposing to use. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ConfigureNotificationFlags + * @param issuerEventId uint32_t + * @param notificationScheme uint8_t + * @param notificationFlagAttributeId uint16_t + * @param clusterId uint16_t + * @param manufacturerCode uint16_t + * @param numberOfCommands uint8_t + * @param commandIds uint8_t* + * @param commandIdsLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationFlags(issuerEventId, \ + notificationScheme, \ + notificationFlagAttributeId, \ + clusterId, \ + manufacturerCode, \ + numberOfCommands, \ + commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, \ + "wuvvvub", \ + issuerEventId, \ + notificationScheme, \ + notificationFlagAttributeId, \ + clusterId, \ + manufacturerCode, \ + numberOfCommands, \ + commandIds, \ + commandIdsLen); + + +/** @brief The GetNotifiedMessage command is used only when a BOMD is being mirrored. This command provides a method for the BOMD to notify the Mirror message queue that it wants to receive commands that the Mirror has queued. The Notification flags set within the command shall inform the mirror of the commands that the BOMD is requesting. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetNotifiedMessage + * @param notificationScheme uint8_t + * @param notificationFlagAttributeId uint16_t + * @param notificationFlagsN uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetNotifiedMessage(notificationScheme, \ + notificationFlagAttributeId, \ + notificationFlagsN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, \ + "uvw", \ + notificationScheme, \ + notificationFlagAttributeId, \ + notificationFlagsN); + + +/** @brief This command is transmitted by a Metering Device in response to a ChangeSupply command. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: SupplyStatusResponse + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param implementationDateTime uint32_t + * @param supplyStatus uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterSupplyStatusResponse(providerId, \ + issuerEventId, \ + implementationDateTime, \ + supplyStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, \ + "wwwu", \ + providerId, \ + issuerEventId, \ + implementationDateTime, \ + supplyStatus); + + +/** @brief This command is transmitted by a Metering Device in response to a StartSampling command. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: StartSamplingResponse + * @param sampleId uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterStartSamplingResponse(sampleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, \ + "v", \ + sampleId); + + +/** @brief The GetProfile command is generated when a client device wishes to retrieve a list of captured Energy, Gas or water consumption for profiling purposes. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetProfile + * @param intervalChannel uint8_t + * @param endTime uint32_t + * @param numberOfPeriods uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetProfile(intervalChannel, \ + endTime, \ + numberOfPeriods) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_PROFILE_COMMAND_ID, \ + "uwu", \ + intervalChannel, \ + endTime, \ + numberOfPeriods); + + +/** @brief The Request Mirror Response Command allows the ESI to inform a sleepy Metering Device it has the ability to store and mirror its data. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: RequestMirrorResponse + * @param endpointId uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterRequestMirrorResponse(endpointId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID, \ + "v", \ + endpointId); + + +/** @brief The Mirror Removed Command allows the ESI to inform a sleepy Metering Device mirroring support has been removed or halted. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: MirrorRemoved + * @param endpointId uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterMirrorRemoved(endpointId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_MIRROR_REMOVED_COMMAND_ID, \ + "v", \ + endpointId); + + +/** @brief The Request Fast Poll Mode command is generated when the metering client wishes to receive near real-time updates of InstantaneousDemand. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: RequestFastPollMode + * @param fastPollUpdatePeriod uint8_t + * @param duration uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterRequestFastPollMode(fastPollUpdatePeriod, \ + duration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID, \ + "uu", \ + fastPollUpdatePeriod, \ + duration); + + +/** @brief This command is used to set up a schedule of when the device shall create snapshot data. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ScheduleSnapshot + * @param issuerEventId uint32_t + * @param commandIndex uint8_t + * @param commandCount uint8_t + * @param snapshotSchedulePayload uint8_t* + * @param snapshotSchedulePayloadLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshot(issuerEventId, \ + commandIndex, \ + commandCount, \ + snapshotSchedulePayload, \ + snapshotSchedulePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID, \ + "wuub", \ + issuerEventId, \ + commandIndex, \ + commandCount, \ + snapshotSchedulePayload, \ + snapshotSchedulePayloadLen); + + +/** @brief This command is used to instruct the cluster server to take a single snapshot. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: TakeSnapshot + * @param snapshotCause uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterTakeSnapshot(snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_TAKE_SNAPSHOT_COMMAND_ID, \ + "w", \ + snapshotCause); + + +/** @brief This command is used to request snapshot data from the cluster server. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetSnapshot + * @param earliestStartTime uint32_t + * @param latestEndTime uint32_t + * @param snapshotOffset uint8_t + * @param snapshotCause uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetSnapshot(earliestStartTime, \ + latestEndTime, \ + snapshotOffset, \ + snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SNAPSHOT_COMMAND_ID, \ + "wwuw", \ + earliestStartTime, \ + latestEndTime, \ + snapshotOffset, \ + snapshotCause); + + +/** @brief The sampling mechanism allows a set of samples of the specified type of data to be taken, commencing at the stipulated start time. This mechanism may run concurrently with the capturing of profile data, and may refer the same parameters, albeit possibly at a different sampling rate. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: StartSampling + * @param issuerEventId uint32_t + * @param startSamplingTime uint32_t + * @param sampleType uint8_t + * @param sampleRequestInterval uint16_t + * @param maxNumberOfSamples uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterStartSampling(issuerEventId, \ + startSamplingTime, \ + sampleType, \ + sampleRequestInterval, \ + maxNumberOfSamples) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_START_SAMPLING_COMMAND_ID, \ + "wwuvv", \ + issuerEventId, \ + startSamplingTime, \ + sampleType, \ + sampleRequestInterval, \ + maxNumberOfSamples); + + +/** @brief This command is used to request sampled data from the server. Note that it is the responsibility of the client to ensure that it does not request more samples than can be held in a single command payload. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: GetSampledData + * @param sampleId uint16_t + * @param earliestSampleTime uint32_t + * @param sampleType uint8_t + * @param numberOfSamples uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterGetSampledData(sampleId, \ + earliestSampleTime, \ + sampleType, \ + numberOfSamples) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SAMPLED_DATA_COMMAND_ID, \ + "vwuv", \ + sampleId, \ + earliestSampleTime, \ + sampleType, \ + numberOfSamples); + + +/** @brief This command is sent in response to the ReportAttribute command when the MirrorReporting attribute is set. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: MirrorReportAttributeResponse + * @param notificationScheme uint8_t + * @param notificationFlags uint8_t* + * @param notificationFlagsLen uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterMirrorReportAttributeResponse(notificationScheme, \ + notificationFlags, \ + notificationFlagsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ID, \ + "ub", \ + notificationScheme, \ + notificationFlags, \ + notificationFlagsLen); + + +/** @brief The ResetLoadLimitCounter command shall cause the LoadLimitCounter attribute to be reset. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ResetLoadLimitCounter + * @param providerId uint32_t + * @param issuerEventId uint32_t + */ +#define emberAfFillCommandSimpleMeteringClusterResetLoadLimitCounter(providerId, \ + issuerEventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID, \ + "ww", \ + providerId, \ + issuerEventId); + + +/** @brief This command is sent from the Head-end or ESI to the Metering Device to instruct it to change the status of the valve or load switch, i.e. the supply. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: ChangeSupply + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param requestDateTime uint32_t + * @param implementationDateTime uint32_t + * @param proposedSupplyStatus uint8_t + * @param supplyControlBits uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterChangeSupply(providerId, \ + issuerEventId, \ + requestDateTime, \ + implementationDateTime, \ + proposedSupplyStatus, \ + supplyControlBits) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CHANGE_SUPPLY_COMMAND_ID, \ + "wwwwuu", \ + providerId, \ + issuerEventId, \ + requestDateTime, \ + implementationDateTime, \ + proposedSupplyStatus, \ + supplyControlBits); + + +/** @brief This command is a simplified version of the ChangeSupply command, intended to be sent from an IHD to a meter as the consequence of a user action on the IHD. Its purpose is to provide a local disconnection/reconnection button on the IHD in addition to the one on the meter. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: LocalChangeSupply + * @param proposedSupplyStatus uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterLocalChangeSupply(proposedSupplyStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID, \ + "u", \ + proposedSupplyStatus); + + +/** @brief This command is used to specify the required status of the supply following the occurance of certain events on the meter. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: SetSupplyStatus + * @param issuerEventId uint32_t + * @param supplyTamperState uint8_t + * @param supplyDepletionState uint8_t + * @param supplyUncontrolledFlowState uint8_t + * @param loadLimitSupplyState uint8_t + */ +#define emberAfFillCommandSimpleMeteringClusterSetSupplyStatus(issuerEventId, \ + supplyTamperState, \ + supplyDepletionState, \ + supplyUncontrolledFlowState, \ + loadLimitSupplyState) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SET_SUPPLY_STATUS_COMMAND_ID, \ + "wuuuu", \ + issuerEventId, \ + supplyTamperState, \ + supplyDepletionState, \ + supplyUncontrolledFlowState, \ + loadLimitSupplyState); + + +/** @brief This command is used to update the 'Uncontrolled Flow Rate' configuration data used by flow meters. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. + * Command: SetUncontrolledFlowThreshold + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param uncontrolledFlowThreshold uint16_t + * @param unitOfMeasure uint8_t + * @param multiplier uint16_t + * @param divisor uint16_t + * @param stabilisationPeriod uint8_t + * @param measurementPeriod uint16_t + */ +#define emberAfFillCommandSimpleMeteringClusterSetUncontrolledFlowThreshold(providerId, \ + issuerEventId, \ + uncontrolledFlowThreshold, \ + unitOfMeasure, \ + multiplier, \ + divisor, \ + stabilisationPeriod, \ + measurementPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, \ + "wwvuvvuv", \ + providerId, \ + issuerEventId, \ + uncontrolledFlowThreshold, \ + unitOfMeasure, \ + multiplier, \ + divisor, \ + stabilisationPeriod, \ + measurementPeriod); + + +/** @} END Simple Metering Commands */ + + +/** @name Messaging Commands */ +// @{ +/** @brief Command description for DisplayMessage + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: DisplayMessage + * @param messageId uint32_t + * @param messageControl uint8_t + * @param startTime uint32_t + * @param durationInMinutes uint16_t + * @param message uint8_t* + * @param optionalExtendedMessageControl uint8_t + */ +#define emberAfFillCommandMessagingClusterDisplayMessage(messageId, \ + messageControl, \ + startTime, \ + durationInMinutes, \ + message, \ + optionalExtendedMessageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_DISPLAY_MESSAGE_COMMAND_ID, \ + "wuwvsu", \ + messageId, \ + messageControl, \ + startTime, \ + durationInMinutes, \ + message, \ + optionalExtendedMessageControl); + + +/** @brief The CancelMessage command provides the ability to cancel the sending or acceptance of previously sent messages. + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: CancelMessage + * @param messageId uint32_t + * @param messageControl uint8_t + */ +#define emberAfFillCommandMessagingClusterCancelMessage(messageId, \ + messageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_CANCEL_MESSAGE_COMMAND_ID, \ + "wu", \ + messageId, \ + messageControl); + + +/** @brief The DisplayProtected Message command is for use with messages that are protected by a password or PIN. + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: DisplayProtectedMessage + * @param messageId uint32_t + * @param messageControl uint8_t + * @param startTime uint32_t + * @param durationInMinutes uint16_t + * @param message uint8_t* + * @param optionalExtendedMessageControl uint8_t + */ +#define emberAfFillCommandMessagingClusterDisplayProtectedMessage(messageId, \ + messageControl, \ + startTime, \ + durationInMinutes, \ + message, \ + optionalExtendedMessageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, \ + "wuwvsu", \ + messageId, \ + messageControl, \ + startTime, \ + durationInMinutes, \ + message, \ + optionalExtendedMessageControl); + + +/** @brief The CancelAllMessages command indicates to a client device that it should cancel all display messages currently held by it. + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: CancelAllMessages + * @param implementationDateTime uint32_t + */ +#define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, \ + "w", \ + implementationDateTime); + + +/** @brief Command description for GetLastMessage + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: GetLastMessage + */ +#define emberAfFillCommandMessagingClusterGetLastMessage() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_GET_LAST_MESSAGE_COMMAND_ID, \ + ""); + + +/** @brief The Message Confirmation command provides an indication that a Utility Customer has acknowledged and/or accepted the contents of a previously sent message. Enhanced Message Confirmation commands shall contain an answer of 'NO', 'YES' and/or a message confirmation string. + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: MessageConfirmation + * @param messageId uint32_t + * @param confirmationTime uint32_t + * @param messageConfirmationControl uint8_t + * @param messageResponse uint8_t* + */ +#define emberAfFillCommandMessagingClusterMessageConfirmation(messageId, \ + confirmationTime, \ + messageConfirmationControl, \ + messageResponse) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_MESSAGE_CONFIRMATION_COMMAND_ID, \ + "wwus", \ + messageId, \ + confirmationTime, \ + messageConfirmationControl, \ + messageResponse); + + +/** @brief This command initiates the return of the first (and maybe only) Cancel All Messages command held on the associated server, and which has an implementation time equal to or later than the value indicated in the payload. + * + * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. + * Command: GetMessageCancellation + * @param earliestImplementationTime uint32_t + */ +#define emberAfFillCommandMessagingClusterGetMessageCancellation(earliestImplementationTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_GET_MESSAGE_CANCELLATION_COMMAND_ID, \ + "w", \ + earliestImplementationTime); + + +/** @} END Messaging Commands */ + + +/** @name Tunneling Commands */ +// @{ +/** @brief RequestTunnel is the client command used to setup a tunnel association with the server. The request payload specifies the protocol identifier for the requested tunnel, a manufacturer code in case of proprietary protocols and the use of flow control for streaming protocols. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: RequestTunnel + * @param protocolId uint8_t + * @param manufacturerCode uint16_t + * @param flowControlSupport uint8_t + * @param maximumIncomingTransferSize uint16_t + */ +#define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, \ + manufacturerCode, \ + flowControlSupport, \ + maximumIncomingTransferSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_REQUEST_TUNNEL_COMMAND_ID, \ + "uvuv", \ + protocolId, \ + manufacturerCode, \ + flowControlSupport, \ + maximumIncomingTransferSize); + + +/** @brief Client command used to close the tunnel with the server. The parameter in the payload specifies the tunnel identifier of the tunnel that has to be closed. The server leaves the tunnel open and the assigned resources allocated until the client sends the CloseTunnel command or the CloseTunnelTimeout fires. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: CloseTunnel + * @param tunnelId uint16_t + */ +#define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_CLOSE_TUNNEL_COMMAND_ID, \ + "v", \ + tunnelId); + + +/** @brief Command that indicates (if received) that the client has sent data to the server. The data itself is contained within the payload. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: TransferDataClientToServer + * @param tunnelId uint16_t + * @param data uint8_t* + * @param dataLen uint16_t + */ +#define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, \ + data, \ + dataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ + "vb", \ + tunnelId, \ + data, \ + dataLen); + + +/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: TransferDataErrorClientToServer + * @param tunnelId uint16_t + * @param transferDataStatus uint8_t + */ +#define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, \ + transferDataStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, \ + "vu", \ + tunnelId, \ + transferDataStatus); + + +/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of octets that may still be received by the receiver. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: AckTransferDataClientToServer + * @param tunnelId uint16_t + * @param numberOfBytesLeft uint16_t + */ +#define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, \ + numberOfBytesLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ + "vv", \ + tunnelId, \ + numberOfBytesLeft); + + +/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: ReadyDataClientToServer + * @param tunnelId uint16_t + * @param numberOfOctetsLeft uint16_t + */ +#define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, \ + numberOfOctetsLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ + "vv", \ + tunnelId, \ + numberOfOctetsLeft); + + +/** @brief Get Supported Tunnel Protocols is the client command used to determine the Tunnel protocols supported on another device. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: GetSupportedTunnelProtocols + * @param protocolOffset uint8_t + */ +#define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, \ + "u", \ + protocolOffset); + + +/** @brief RequestTunnelResponse is sent by the server in response to a RequestTunnel command previously received from the client. The response contains the status of the RequestTunnel command and a tunnel identifier corresponding to the tunnel that has been set-up in the server in case of success. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: RequestTunnelResponse + * @param tunnelId uint16_t + * @param tunnelStatus uint8_t + * @param maximumIncomingTransferSize uint16_t + */ +#define emberAfFillCommandTunnelingClusterRequestTunnelResponse(tunnelId, \ + tunnelStatus, \ + maximumIncomingTransferSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID, \ + "vuv", \ + tunnelId, \ + tunnelStatus, \ + maximumIncomingTransferSize); + + +/** @brief Command that transfers data from server to the client. The data itself has to be placed within the payload. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: TransferDataServerToClient + * @param tunnelId uint16_t + * @param data uint8_t* + * @param dataLen uint16_t + */ +#define emberAfFillCommandTunnelingClusterTransferDataServerToClient(tunnelId, \ + data, \ + dataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ + "vb", \ + tunnelId, \ + data, \ + dataLen); + + +/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: TransferDataErrorServerToClient + * @param tunnelId uint16_t + * @param transferDataStatus uint8_t + */ +#define emberAfFillCommandTunnelingClusterTransferDataErrorServerToClient(tunnelId, \ + transferDataStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_ERROR_SERVER_TO_CLIENT_COMMAND_ID, \ + "vu", \ + tunnelId, \ + transferDataStatus); + + +/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of octets that may still be received by the receiver. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: AckTransferDataServerToClient + * @param tunnelId uint16_t + * @param numberOfBytesLeft uint16_t + */ +#define emberAfFillCommandTunnelingClusterAckTransferDataServerToClient(tunnelId, \ + numberOfBytesLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ + "vv", \ + tunnelId, \ + numberOfBytesLeft); + + +/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: ReadyDataServerToClient + * @param tunnelId uint16_t + * @param numberOfOctetsLeft uint16_t + */ +#define emberAfFillCommandTunnelingClusterReadyDataServerToClient(tunnelId, \ + numberOfOctetsLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ + "vv", \ + tunnelId, \ + numberOfOctetsLeft); + + +/** @brief Supported Tunnel Protocol Response is sent in response to a Get Supported Tunnel Protocols command previously received. The response contains a list of Tunnel protocols supported by the device; the payload of the response should be capable of holding up to 16 protocols. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: SupportedTunnelProtocolsResponse + * @param protocolListComplete uint8_t + * @param protocolCount uint8_t + * @param protocolList uint8_t* + * @param protocolListLen uint16_t + */ +#define emberAfFillCommandTunnelingClusterSupportedTunnelProtocolsResponse(protocolListComplete, \ + protocolCount, \ + protocolList, \ + protocolListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID, \ + "uub", \ + protocolListComplete, \ + protocolCount, \ + protocolList, \ + protocolListLen); + + +/** @brief TunnelClosureNotification is sent by the server to indicate that a tunnel has been closed due to expiration of a CloseTunnelTimeout. + * + * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. + * Command: TunnelClosureNotification + * @param tunnelId uint16_t + */ +#define emberAfFillCommandTunnelingClusterTunnelClosureNotification(tunnelId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID, \ + "v", \ + tunnelId); + + +/** @} END Tunneling Commands */ + + +/** @name Prepayment Commands */ +// @{ +/** @brief This command is sent to the Metering Device to activate the use of any Emergency Credit available on the Metering Device. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: SelectAvailableEmergencyCredit + * @param commandIssueDateTime uint32_t + * @param originatingDevice uint8_t + */ +#define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, \ + originatingDevice) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, \ + "wu", \ + commandIssueDateTime, \ + originatingDevice); + + +/** @brief The ChangeDebt command is send to the Metering Device to change the fuel or Non fuel debt values. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: ChangeDebt + * @param issuerEventId uint32_t + * @param debtLabel uint8_t* + * @param debtAmount uint32_t + * @param debtRecoveryMethod uint8_t + * @param debtAmountType uint8_t + * @param debtRecoveryStartTime uint32_t + * @param debtRecoveryCollectionTime uint16_t + * @param debtRecoveryFrequency uint8_t + * @param debtRecoveryAmount uint32_t + * @param debtRecoveryBalancePercentage uint16_t + */ +#define emberAfFillCommandPrepaymentClusterChangeDebt(issuerEventId, \ + debtLabel, \ + debtAmount, \ + debtRecoveryMethod, \ + debtAmountType, \ + debtRecoveryStartTime, \ + debtRecoveryCollectionTime, \ + debtRecoveryFrequency, \ + debtRecoveryAmount, \ + debtRecoveryBalancePercentage) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_DEBT_COMMAND_ID, \ + "wswuuwvuwv", \ + issuerEventId, \ + debtLabel, \ + debtAmount, \ + debtRecoveryMethod, \ + debtAmountType, \ + debtRecoveryStartTime, \ + debtRecoveryCollectionTime, \ + debtRecoveryFrequency, \ + debtRecoveryAmount, \ + debtRecoveryBalancePercentage); + + +/** @brief This command is a method to set up the parameters for the emergency credit. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: EmergencyCreditSetup + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param emergencyCreditLimit uint32_t + * @param emergencyCreditThreshold uint32_t + */ +#define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, \ + startTime, \ + emergencyCreditLimit, \ + emergencyCreditThreshold) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, \ + "wwww", \ + issuerEventId, \ + startTime, \ + emergencyCreditLimit, \ + emergencyCreditThreshold); + + +/** @brief The ConsumerTopUp command is used by the IPD and the ESI as a method of applying credit top up values to the prepayment meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: ConsumerTopUp + * @param originatingDevice uint8_t + * @param topUpCode uint8_t* + */ +#define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, \ + topUpCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CONSUMER_TOP_UP_COMMAND_ID, \ + "us", \ + originatingDevice, \ + topUpCode); + + +/** @brief The CreditAdjustment command is sent to update the accounting base for the Prepayment meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: CreditAdjustment + * @param issuerEventId uint32_t + * @param startTime uint32_t + * @param creditAdjustmentType uint8_t + * @param creditAdjustmentValue uint32_t + */ +#define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, \ + startTime, \ + creditAdjustmentType, \ + creditAdjustmentValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, \ + "wwuw", \ + issuerEventId, \ + startTime, \ + creditAdjustmentType, \ + creditAdjustmentValue); + + +/** @brief This command is sent to a Metering Device to instruct it to change its mode of operation. i.e. from Credit to Prepayment. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: ChangePaymentMode + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param implementationDateTime uint32_t + * @param proposedPaymentControlConfiguration uint16_t + * @param cutOffValue uint32_t + */ +#define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, \ + issuerEventId, \ + implementationDateTime, \ + proposedPaymentControlConfiguration, \ + cutOffValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, \ + "wwwvw", \ + providerId, \ + issuerEventId, \ + implementationDateTime, \ + proposedPaymentControlConfiguration, \ + cutOffValue); + + +/** @brief This command is used to request the cluster server for snapshot data. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: GetPrepaySnapshot + * @param earliestStartTime uint32_t + * @param latestEndTime uint32_t + * @param snapshotOffset uint8_t + * @param snapshotCause uint32_t + */ +#define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, \ + latestEndTime, \ + snapshotOffset, \ + snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, \ + "wwuw", \ + earliestStartTime, \ + latestEndTime, \ + snapshotOffset, \ + snapshotCause); + + +/** @brief This command is sent to the Metering Device to retrieve the log of Top Up codes received by the meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: GetTopUpLog + * @param latestEndTime uint32_t + * @param numberOfRecords uint8_t + */ +#define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, \ + numberOfRecords) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_TOP_UP_LOG_COMMAND_ID, \ + "wu", \ + latestEndTime, \ + numberOfRecords); + + +/** @brief This command is sent from client to a Prepayment server to set the warning level for low credit. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: SetLowCreditWarningLevel + * @param lowCreditWarningLevel uint32_t + */ +#define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, \ + "w", \ + lowCreditWarningLevel); + + +/** @brief This command is used to request the contents of the repayment log. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: GetDebtRepaymentLog + * @param latestEndTime uint32_t + * @param numberOfDebts uint8_t + * @param debtType uint8_t + */ +#define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, \ + numberOfDebts, \ + debtType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, \ + "wuu", \ + latestEndTime, \ + numberOfDebts, \ + debtType); + + +/** @brief This command is sent from a client to the Prepayment server to set the maximum credit level allowed in the meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: SetMaximumCreditLimit + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param implementationDateTime uint32_t + * @param maximumCreditLevel uint32_t + * @param maximumCreditPerTopUp uint32_t + */ +#define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, \ + issuerEventId, \ + implementationDateTime, \ + maximumCreditLevel, \ + maximumCreditPerTopUp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, \ + "wwwww", \ + providerId, \ + issuerEventId, \ + implementationDateTime, \ + maximumCreditLevel, \ + maximumCreditPerTopUp); + + +/** @brief This command is sent from a client to the Prepayment server to set the overall debt cap allowed in the meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: SetOverallDebtCap + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param implementationDateTime uint32_t + * @param overallDebtCap uint32_t + */ +#define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, \ + issuerEventId, \ + implementationDateTime, \ + overallDebtCap) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, \ + "wwww", \ + providerId, \ + issuerEventId, \ + implementationDateTime, \ + overallDebtCap); + + +/** @brief This command is generated in response to a GetPrepaySnapshot command. It is used to return a single snapshot to the client. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: PublishPrepaySnapshot + * @param snapshotId uint32_t + * @param snapshotTime uint32_t + * @param totalSnapshotsFound uint8_t + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param snapshotCause uint32_t + * @param snapshotPayloadType uint8_t + * @param snapshotPayload uint8_t* + * @param snapshotPayloadLen uint16_t + */ +#define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, \ + snapshotTime, \ + totalSnapshotsFound, \ + commandIndex, \ + totalNumberOfCommands, \ + snapshotCause, \ + snapshotPayloadType, \ + snapshotPayload, \ + snapshotPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, \ + "wwuuuwub", \ + snapshotId, \ + snapshotTime, \ + totalSnapshotsFound, \ + commandIndex, \ + totalNumberOfCommands, \ + snapshotCause, \ + snapshotPayloadType, \ + snapshotPayload, \ + snapshotPayloadLen); + + +/** @brief This command is send in response to the ChangePaymentMode Command. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: ChangePaymentModeResponse + * @param friendlyCredit uint8_t + * @param friendlyCreditCalendarId uint32_t + * @param emergencyCreditLimit uint32_t + * @param emergencyCreditThreshold uint32_t + */ +#define emberAfFillCommandPrepaymentClusterChangePaymentModeResponse(friendlyCredit, \ + friendlyCreditCalendarId, \ + emergencyCreditLimit, \ + emergencyCreditThreshold) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_PAYMENT_MODE_RESPONSE_COMMAND_ID, \ + "uwww", \ + friendlyCredit, \ + friendlyCreditCalendarId, \ + emergencyCreditLimit, \ + emergencyCreditThreshold); + + +/** @brief This command is send in response to the ConsumerTopUp Command. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: ConsumerTopUpResponse + * @param resultType uint8_t + * @param topUpValue uint32_t + * @param sourceOfTopUp uint8_t + * @param creditRemaining uint32_t + */ +#define emberAfFillCommandPrepaymentClusterConsumerTopUpResponse(resultType, \ + topUpValue, \ + sourceOfTopUp, \ + creditRemaining) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID, \ + "uwuw", \ + resultType, \ + topUpValue, \ + sourceOfTopUp, \ + creditRemaining); + + +/** @brief This command is used to send the Top Up Code Log entries to the client. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: PublishTopUpLog + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param topUpPayload uint8_t* + * @param topUpPayloadLen uint16_t + */ +#define emberAfFillCommandPrepaymentClusterPublishTopUpLog(commandIndex, \ + totalNumberOfCommands, \ + topUpPayload, \ + topUpPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID, \ + "uub", \ + commandIndex, \ + totalNumberOfCommands, \ + topUpPayload, \ + topUpPayloadLen); + + +/** @brief This command is used to send the contents of the Repayment Log. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. + * Command: PublishDebtLog + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param debtPayload uint8_t* + * @param debtPayloadLen uint16_t + */ +#define emberAfFillCommandPrepaymentClusterPublishDebtLog(commandIndex, \ + totalNumberOfCommands, \ + debtPayload, \ + debtPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_DEBT_LOG_COMMAND_ID, \ + "uub", \ + commandIndex, \ + totalNumberOfCommands, \ + debtPayload, \ + debtPayloadLen); + + +/** @} END Prepayment Commands */ + + +/** @name Energy Management Commands */ +// @{ +/** @brief This command is reused from the DRLC cluster. This command is generated in response to the Manage Event command. + * + * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring protocols. + * Command: ReportEventStatus + * @param issuerEventId uint32_t + * @param eventStatus uint8_t + * @param eventStatusTime uint32_t + * @param criticalityLevelApplied uint8_t + * @param coolingTemperatureSetPointApplied uint16_t + * @param heatingTemperatureSetPointApplied uint16_t + * @param averageLoadAdjustmentPercentageApplied int8_t + * @param dutyCycleApplied uint8_t + * @param eventControl uint8_t + */ +#define emberAfFillCommandEnergyManagementClusterReportEventStatus(issuerEventId, \ + eventStatus, \ + eventStatusTime, \ + criticalityLevelApplied, \ + coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, \ + averageLoadAdjustmentPercentageApplied, \ + dutyCycleApplied, \ + eventControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, \ + ZCL_REPORT_EVENT_STATUS_COMMAND_ID, \ + "wuwuvvuuu", \ + issuerEventId, \ + eventStatus, \ + eventStatusTime, \ + criticalityLevelApplied, \ + coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, \ + averageLoadAdjustmentPercentageApplied, \ + dutyCycleApplied, \ + eventControl); + + +/** @brief The Manage Event command allows a remote device (such as an IHD or web portal) to change the behavior of a DRLC cluster client when responding to a DRLC Load Control Event. + * + * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring protocols. + * Command: ManageEvent + * @param issuerEventId uint32_t + * @param deviceClass uint16_t + * @param utilityEnrollmentGroup uint8_t + * @param actionRequired uint8_t + */ +#define emberAfFillCommandEnergyManagementClusterManageEvent(issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + actionRequired) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, \ + ZCL_MANAGE_EVENT_COMMAND_ID, \ + "wvuu", \ + issuerEventId, \ + deviceClass, \ + utilityEnrollmentGroup, \ + actionRequired); + + +/** @} END Energy Management Commands */ + + +/** @name Calendar Commands */ +// @{ +/** @brief The PublishCalendar command is published in response to a GetCalendar command or if new calendar information is available. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: PublishCalendar + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerCalendarId uint32_t + * @param startTime uint32_t + * @param calendarType uint8_t + * @param calendarTimeReference uint8_t + * @param calendarName uint8_t* + * @param numberOfSeasons uint8_t + * @param numberOfWeekProfiles uint8_t + * @param numberOfDayProfiles uint8_t + */ +#define emberAfFillCommandCalendarClusterPublishCalendar(providerId, \ + issuerEventId, \ + issuerCalendarId, \ + startTime, \ + calendarType, \ + calendarTimeReference, \ + calendarName, \ + numberOfSeasons, \ + numberOfWeekProfiles, \ + numberOfDayProfiles) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_CALENDAR_COMMAND_ID, \ + "wwwwuusuuu", \ + providerId, \ + issuerEventId, \ + issuerCalendarId, \ + startTime, \ + calendarType, \ + calendarTimeReference, \ + calendarName, \ + numberOfSeasons, \ + numberOfWeekProfiles, \ + numberOfDayProfiles); + + +/** @brief The PublishDayProfile command is published in response to a GetDayProfile command. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: PublishDayProfile + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerCalendarId uint32_t + * @param dayId uint8_t + * @param totalNumberOfScheduleEntries uint8_t + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param calendarType uint8_t + * @param dayScheduleEntries uint8_t* + * @param dayScheduleEntriesLen uint16_t + */ +#define emberAfFillCommandCalendarClusterPublishDayProfile(providerId, \ + issuerEventId, \ + issuerCalendarId, \ + dayId, \ + totalNumberOfScheduleEntries, \ + commandIndex, \ + totalNumberOfCommands, \ + calendarType, \ + dayScheduleEntries, \ + dayScheduleEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, \ + "wwwuuuuub", \ + providerId, \ + issuerEventId, \ + issuerCalendarId, \ + dayId, \ + totalNumberOfScheduleEntries, \ + commandIndex, \ + totalNumberOfCommands, \ + calendarType, \ + dayScheduleEntries, \ + dayScheduleEntriesLen); + + +/** @brief The PublishWeekProfile command is published in response to a GetWeekProfile command. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: PublishWeekProfile + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerCalendarId uint32_t + * @param weekId uint8_t + * @param dayIdRefMonday uint8_t + * @param dayIdRefTuesday uint8_t + * @param dayIdRefWednesday uint8_t + * @param dayIdRefThursday uint8_t + * @param dayIdRefFriday uint8_t + * @param dayIdRefSaturday uint8_t + * @param dayIdRefSunday uint8_t + */ +#define emberAfFillCommandCalendarClusterPublishWeekProfile(providerId, \ + issuerEventId, \ + issuerCalendarId, \ + weekId, \ + dayIdRefMonday, \ + dayIdRefTuesday, \ + dayIdRefWednesday, \ + dayIdRefThursday, \ + dayIdRefFriday, \ + dayIdRefSaturday, \ + dayIdRefSunday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, \ + "wwwuuuuuuuu", \ + providerId, \ + issuerEventId, \ + issuerCalendarId, \ + weekId, \ + dayIdRefMonday, \ + dayIdRefTuesday, \ + dayIdRefWednesday, \ + dayIdRefThursday, \ + dayIdRefFriday, \ + dayIdRefSaturday, \ + dayIdRefSunday); + + +/** @brief The PublishSeasons command is published in response to a GetSeason command. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: PublishSeasons + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerCalendarId uint32_t + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param seasonEntries uint8_t* + * @param seasonEntriesLen uint16_t + */ +#define emberAfFillCommandCalendarClusterPublishSeasons(providerId, \ + issuerEventId, \ + issuerCalendarId, \ + commandIndex, \ + totalNumberOfCommands, \ + seasonEntries, \ + seasonEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_SEASONS_COMMAND_ID, \ + "wwwuub", \ + providerId, \ + issuerEventId, \ + issuerCalendarId, \ + commandIndex, \ + totalNumberOfCommands, \ + seasonEntries, \ + seasonEntriesLen); + + +/** @brief The PublishSpecialDays command is published in response to a GetSpecialDays command or if a calendar update is available. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: PublishSpecialDays + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param issuerCalendarId uint32_t + * @param startTime uint32_t + * @param calendarType uint8_t + * @param totalNumberOfSpecialDays uint8_t + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param specialDayEntries uint8_t* + * @param specialDayEntriesLen uint16_t + */ +#define emberAfFillCommandCalendarClusterPublishSpecialDays(providerId, \ + issuerEventId, \ + issuerCalendarId, \ + startTime, \ + calendarType, \ + totalNumberOfSpecialDays, \ + commandIndex, \ + totalNumberOfCommands, \ + specialDayEntries, \ + specialDayEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, \ + "wwwwuuuub", \ + providerId, \ + issuerEventId, \ + issuerCalendarId, \ + startTime, \ + calendarType, \ + totalNumberOfSpecialDays, \ + commandIndex, \ + totalNumberOfCommands, \ + specialDayEntries, \ + specialDayEntriesLen); + + +/** @brief The CancelCalendar command indicates that all data associated with a particular calendar instance should be discarded. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: CancelCalendar + * @param providerId uint32_t + * @param issuerCalendarId uint32_t + * @param calendarType uint8_t + */ +#define emberAfFillCommandCalendarClusterCancelCalendar(providerId, \ + issuerCalendarId, \ + calendarType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_CANCEL_CALENDAR_COMMAND_ID, \ + "wwu", \ + providerId, \ + issuerCalendarId, \ + calendarType); + + +/** @brief This command initiates PublishCalendar command(s) for scheduled Calendar updates. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetCalendar + * @param earliestStartTime uint32_t + * @param minIssuerEventId uint32_t + * @param numberOfCalendars uint8_t + * @param calendarType uint8_t + * @param providerId uint32_t + */ +#define emberAfFillCommandCalendarClusterGetCalendar(earliestStartTime, \ + minIssuerEventId, \ + numberOfCalendars, \ + calendarType, \ + providerId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_CALENDAR_COMMAND_ID, \ + "wwuuw", \ + earliestStartTime, \ + minIssuerEventId, \ + numberOfCalendars, \ + calendarType, \ + providerId); + + +/** @brief This command initiates one or more PublishDayProfile commands for the referenced Calendar. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetDayProfiles + * @param providerId uint32_t + * @param issuerCalendarId uint32_t + * @param startDayId uint8_t + * @param numberOfDays uint8_t + */ +#define emberAfFillCommandCalendarClusterGetDayProfiles(providerId, \ + issuerCalendarId, \ + startDayId, \ + numberOfDays) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_DAY_PROFILES_COMMAND_ID, \ + "wwuu", \ + providerId, \ + issuerCalendarId, \ + startDayId, \ + numberOfDays); + + +/** @brief This command initiates one or more PublishWeekProfile commands for the referenced Calendar. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetWeekProfiles + * @param providerId uint32_t + * @param issuerCalendarId uint32_t + * @param startWeekId uint8_t + * @param numberOfWeeks uint8_t + */ +#define emberAfFillCommandCalendarClusterGetWeekProfiles(providerId, \ + issuerCalendarId, \ + startWeekId, \ + numberOfWeeks) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_WEEK_PROFILES_COMMAND_ID, \ + "wwuu", \ + providerId, \ + issuerCalendarId, \ + startWeekId, \ + numberOfWeeks); + + +/** @brief This command initiates one or more PublishSeasons commands for the referenced Calendar. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetSeasons + * @param providerId uint32_t + * @param issuerCalendarId uint32_t + */ +#define emberAfFillCommandCalendarClusterGetSeasons(providerId, \ + issuerCalendarId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_SEASONS_COMMAND_ID, \ + "ww", \ + providerId, \ + issuerCalendarId); + + +/** @brief This command initiates one or more PublishSpecialDays commands for the scheduled Special Day Table updates. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetSpecialDays + * @param startTime uint32_t + * @param numberOfEvents uint8_t + * @param calendarType uint8_t + * @param providerId uint32_t + * @param issuerCalendarId uint32_t + */ +#define emberAfFillCommandCalendarClusterGetSpecialDays(startTime, \ + numberOfEvents, \ + calendarType, \ + providerId, \ + issuerCalendarId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_SPECIAL_DAYS_COMMAND_ID, \ + "wuuww", \ + startTime, \ + numberOfEvents, \ + calendarType, \ + providerId, \ + issuerCalendarId); + + +/** @brief This command initiates the return of the last CancelCalendar command held on the associated server. + * + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. + * Command: GetCalendarCancellation + */ +#define emberAfFillCommandCalendarClusterGetCalendarCancellation() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, \ + ""); + + +/** @} END Calendar Commands */ + + +/** @name Device Management Commands */ +// @{ +/** @brief This command is used to request the ESI to respond with information regarding any available change of tenancy. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: GetChangeOfTenancy + */ +#define emberAfFillCommandDeviceManagementClusterGetChangeOfTenancy() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, \ + ""); + + +/** @brief This command is used to request the ESI to respond with information regarding any available change of supplier. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: GetChangeOfSupplier + */ +#define emberAfFillCommandDeviceManagementClusterGetChangeOfSupplier() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, \ + ""); + + +/** @brief This command is used to request the current password from the server. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: RequestNewPassword + * @param passwordType uint8_t + */ +#define emberAfFillCommandDeviceManagementClusterRequestNewPassword(passwordType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, \ + "u", \ + passwordType); + + +/** @brief This command is used to request the ESI to respond with information regarding any pending change of Site ID. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: GetSiteId + */ +#define emberAfFillCommandDeviceManagementClusterGetSiteId() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_GET_SITE_ID_COMMAND_ID, \ + ""); + + +/** @brief This command is sent in response to a GetEventConfiguration command. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: ReportEventConfiguration + * @param commandIndex uint8_t + * @param totalCommands uint8_t + * @param eventConfigurationPayload uint8_t* + * @param eventConfigurationPayloadLen uint16_t + */ +#define emberAfFillCommandDeviceManagementClusterReportEventConfiguration(commandIndex, \ + totalCommands, \ + eventConfigurationPayload, \ + eventConfigurationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, \ + "uub", \ + commandIndex, \ + totalCommands, \ + eventConfigurationPayload, \ + eventConfigurationPayloadLen); + + +/** @brief This command is used to request the ESI to respond with information regarding any pending change of Customer ID Number. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: GetCIN + */ +#define emberAfFillCommandDeviceManagementClusterGetCIN() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_GET_C_I_N_COMMAND_ID, \ + ""); + + +/** @brief This command is used to change the tenancy of a meter. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: PublishChangeOfTenancy + * @param providerId uint32_t + * @param issuerEventId uint32_t + * @param tariffType uint8_t + * @param implementationDateTime uint32_t + * @param proposedTenancyChangeControl uint32_t + */ +#define emberAfFillCommandDeviceManagementClusterPublishChangeOfTenancy(providerId, \ + issuerEventId, \ + tariffType, \ + implementationDateTime, \ + proposedTenancyChangeControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID, \ + "wwuww", \ + providerId, \ + issuerEventId, \ + tariffType, \ + implementationDateTime, \ + proposedTenancyChangeControl); + + +/** @brief This command is used to change the Supplier (energy supplier) that is supplying the meter (s). + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: PublishChangeOfSupplier + * @param currentProviderId uint32_t + * @param issuerEventId uint32_t + * @param tariffType uint8_t + * @param proposedProviderId uint32_t + * @param providerChangeImplementationTime uint32_t + * @param providerChangeControl uint32_t + * @param proposedProviderName uint8_t* + * @param proposedProviderContactDetails uint8_t* + */ +#define emberAfFillCommandDeviceManagementClusterPublishChangeOfSupplier(currentProviderId, \ + issuerEventId, \ + tariffType, \ + proposedProviderId, \ + providerChangeImplementationTime, \ + providerChangeControl, \ + proposedProviderName, \ + proposedProviderContactDetails) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID, \ + "wwuwwwss", \ + currentProviderId, \ + issuerEventId, \ + tariffType, \ + proposedProviderId, \ + providerChangeImplementationTime, \ + providerChangeControl, \ + proposedProviderName, \ + proposedProviderContactDetails); + + +/** @brief This command is used to send the current password to the client. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: RequestNewPasswordResponse + * @param issuerEventId uint32_t + * @param implementationDateTime uint32_t + * @param durationInMinutes uint16_t + * @param passwordType uint8_t + * @param password uint8_t* + */ +#define emberAfFillCommandDeviceManagementClusterRequestNewPasswordResponse(issuerEventId, \ + implementationDateTime, \ + durationInMinutes, \ + passwordType, \ + password) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_REQUEST_NEW_PASSWORD_RESPONSE_COMMAND_ID, \ + "wwvus", \ + issuerEventId, \ + implementationDateTime, \ + durationInMinutes, \ + passwordType, \ + password); + + +/** @brief This command is used to set the siteID. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: UpdateSiteId + * @param issuerEventId uint32_t + * @param siteIdTime uint32_t + * @param providerId uint32_t + * @param siteId uint8_t* + */ +#define emberAfFillCommandDeviceManagementClusterUpdateSiteId(issuerEventId, \ + siteIdTime, \ + providerId, \ + siteId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_UPDATE_SITE_ID_COMMAND_ID, \ + "wwws", \ + issuerEventId, \ + siteIdTime, \ + providerId, \ + siteId); + + +/** @brief This command provides a method to set the event configuration attributes, held in a client device. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: SetEventConfiguration + * @param issuerEventId uint32_t + * @param startDateTime uint32_t + * @param eventConfiguration uint8_t + * @param configurationControl uint8_t + * @param eventConfigurationPayload uint8_t* + * @param eventConfigurationPayloadLen uint16_t + */ +#define emberAfFillCommandDeviceManagementClusterSetEventConfiguration(issuerEventId, \ + startDateTime, \ + eventConfiguration, \ + configurationControl, \ + eventConfigurationPayload, \ + eventConfigurationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID, \ + "wwuub", \ + issuerEventId, \ + startDateTime, \ + eventConfiguration, \ + configurationControl, \ + eventConfigurationPayload, \ + eventConfigurationPayloadLen); + + +/** @brief This command allows the server to request details of event configurations. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: GetEventConfiguration + * @param eventId uint16_t + */ +#define emberAfFillCommandDeviceManagementClusterGetEventConfiguration(eventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID, \ + "v", \ + eventId); + + +/** @brief This command is used to set the CustomerIDNumber attribute held in the Metering cluster. + * + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. + * Command: UpdateCIN + * @param issuerEventId uint32_t + * @param implementationTime uint32_t + * @param providerId uint32_t + * @param customerIdNumber uint8_t* + */ +#define emberAfFillCommandDeviceManagementClusterUpdateCIN(issuerEventId, \ + implementationTime, \ + providerId, \ + customerIdNumber) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ + ZCL_UPDATE_C_I_N_COMMAND_ID, \ + "wwws", \ + issuerEventId, \ + implementationTime, \ + providerId, \ + customerIdNumber); + + +/** @} END Device Management Commands */ + + +/** @name Events Commands */ +// @{ +/** @brief The GetEventLog command allows a client to request events from a server's event logs. One or more PublishEventLog commands are returned on receipt of this command. + * + * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. + * Command: GetEventLog + * @param eventControlLogId uint8_t + * @param eventId uint16_t + * @param startTime uint32_t + * @param endTime uint32_t + * @param numberOfEvents uint8_t + * @param eventOffset uint16_t + */ +#define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, \ + eventId, \ + startTime, \ + endTime, \ + numberOfEvents, \ + eventOffset) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_EVENTS_CLUSTER_ID, \ + ZCL_GET_EVENT_LOG_COMMAND_ID, \ + "uvwwuv", \ + eventControlLogId, \ + eventId, \ + startTime, \ + endTime, \ + numberOfEvents, \ + eventOffset); + + +/** @brief The ClearEventLogRequest command requests that an Events server device clear the specified event log(s). + * + * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. + * Command: ClearEventLogRequest + * @param logId uint8_t + */ +#define emberAfFillCommandEventsClusterClearEventLogRequest(logId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_EVENTS_CLUSTER_ID, \ + ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, \ + "u", \ + logId); + + +/** @brief The PublishEvent command is generated upon an event trigger from within the reporting device and, if supported, the associated Event Configuration attribute in the Device Management cluster. + * + * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. + * Command: PublishEvent + * @param logId uint8_t + * @param eventId uint16_t + * @param eventTime uint32_t + * @param eventControl uint8_t + * @param eventData uint8_t* + */ +#define emberAfFillCommandEventsClusterPublishEvent(logId, \ + eventId, \ + eventTime, \ + eventControl, \ + eventData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_EVENTS_CLUSTER_ID, \ + ZCL_PUBLISH_EVENT_COMMAND_ID, \ + "uvwus", \ + logId, \ + eventId, \ + eventTime, \ + eventControl, \ + eventData); + + +/** @brief This command is generated on receipt of a GetEventLog command. The command returns the most recent event first and up to the number of events requested. + * + * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. + * Command: PublishEventLog + * @param totalNumberOfEvents uint16_t + * @param commandIndex uint8_t + * @param totalCommands uint8_t + * @param logPayloadControl uint8_t + * @param logPayload uint8_t* + * @param logPayloadLen uint16_t + */ +#define emberAfFillCommandEventsClusterPublishEventLog(totalNumberOfEvents, \ + commandIndex, \ + totalCommands, \ + logPayloadControl, \ + logPayload, \ + logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_EVENTS_CLUSTER_ID, \ + ZCL_PUBLISH_EVENT_LOG_COMMAND_ID, \ + "vuuub", \ + totalNumberOfEvents, \ + commandIndex, \ + totalCommands, \ + logPayloadControl, \ + logPayload, \ + logPayloadLen); + + +/** @brief This command is generated on receipt of a Clear Event Log Request command. + * + * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. + * Command: ClearEventLogResponse + * @param clearedEventsLogs uint8_t + */ +#define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_EVENTS_CLUSTER_ID, \ + ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, \ + "u", \ + clearedEventsLogs); + + +/** @} END Events Commands */ + + +/** @name MDU Pairing Commands */ +// @{ +/** @brief The Pairing Response command provides a device joining a MDU network with a list of the devices that will constitute the 'virtual HAN' for the household in which the joining device is to operate. + * + * Cluster: MDU Pairing, This cluster seeks to assist in the commissioning of networks that include multi-dwelling units (MDUs). + * Command: PairingResponse + * @param pairingInformationVersion uint32_t + * @param totalNumberOfDevices uint8_t + * @param commandIndex uint8_t + * @param totalNumberOfCommands uint8_t + * @param eui64s uint8_t* + * @param eui64sLen uint16_t + */ +#define emberAfFillCommandMduPairingClusterPairingResponse(pairingInformationVersion, \ + totalNumberOfDevices, \ + commandIndex, \ + totalNumberOfCommands, \ + eui64s, \ + eui64sLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_MDU_PAIRING_CLUSTER_ID, \ + ZCL_PAIRING_RESPONSE_COMMAND_ID, \ + "wuuub", \ + pairingInformationVersion, \ + totalNumberOfDevices, \ + commandIndex, \ + totalNumberOfCommands, \ + eui64s, \ + eui64sLen); + + +/** @brief The Pairing Request command allows a device joining a MDU network to determine the devices that will constitute the 'virtual HAN' for the household in which it is to operate. + * + * Cluster: MDU Pairing, This cluster seeks to assist in the commissioning of networks that include multi-dwelling units (MDUs). + * Command: PairingRequest + * @param localPairingInformationVersion uint32_t + * @param eui64OfRequestingDevice uint8_t* + */ +#define emberAfFillCommandMduPairingClusterPairingRequest(localPairingInformationVersion, \ + eui64OfRequestingDevice) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MDU_PAIRING_CLUSTER_ID, \ + ZCL_PAIRING_REQUEST_COMMAND_ID, \ + "w8", \ + localPairingInformationVersion, \ + eui64OfRequestingDevice); + + +/** @} END MDU Pairing Commands */ + + +/** @name Sub-GHz Commands */ +// @{ +/** @brief The server sends it to temporarily suspend ZCL messages from clients it identifies as causing too much traffic. + * + * Cluster: Sub-GHz, Used by the Smart Energy profile for duty cycle monitoring and frequency agility. + * Command: SuspendZclMessages + * @param period uint8_t + */ +#define emberAfFillCommandSubGhzClusterSuspendZclMessages(period) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SUB_GHZ_CLUSTER_ID, \ + ZCL_SUSPEND_ZCL_MESSAGES_COMMAND_ID, \ + "u", \ + period); + + +/** @brief The client sends it to determine the current status of its ZCL communications from the server. + * + * Cluster: Sub-GHz, Used by the Smart Energy profile for duty cycle monitoring and frequency agility. + * Command: GetSuspendZclMessagesStatus + */ +#define emberAfFillCommandSubGhzClusterGetSuspendZclMessagesStatus() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SUB_GHZ_CLUSTER_ID, \ + ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, \ + ""); + + +/** @} END Sub-GHz Commands */ + + +/** @name Key Establishment Commands */ +// @{ +/** @brief Command description for InitiateKeyEstablishmentRequest + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: InitiateKeyEstablishmentRequest + * @param keyEstablishmentSuite uint16_t + * @param ephemeralDataGenerateTime uint8_t + * @param confirmKeyGenerateTime uint8_t + * @param identity uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, \ + ephemeralDataGenerateTime, \ + confirmKeyGenerateTime, \ + identity) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, \ + "vuub", \ + keyEstablishmentSuite, \ + ephemeralDataGenerateTime, \ + confirmKeyGenerateTime, \ + identity, \ + 48); + + +/** @brief Command description for EphemeralDataRequest + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: EphemeralDataRequest + * @param ephemeralData uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataRequest(ephemeralData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, \ + "b", \ + ephemeralData, \ + 22); + + +/** @brief Command description for ConfirmKeyDataRequest + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: ConfirmKeyDataRequest + * @param secureMessageAuthenticationCode uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, \ + "G", \ + secureMessageAuthenticationCode); + + +/** @brief Command description for TerminateKeyEstablishment + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: TerminateKeyEstablishment + * @param statusCode uint8_t + * @param waitTime uint8_t + * @param keyEstablishmentSuite uint16_t + */ +#define emberAfFillCommandKeyEstablishmentClusterServerToClientTerminateKeyEstablishment(statusCode, \ + waitTime, \ + keyEstablishmentSuite) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, \ + "uuv", \ + statusCode, \ + waitTime, \ + keyEstablishmentSuite); + + +/** @brief Command description for TerminateKeyEstablishment + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: TerminateKeyEstablishment + * @param statusCode uint8_t + * @param waitTime uint8_t + * @param keyEstablishmentSuite uint16_t + */ +#define emberAfFillCommandKeyEstablishmentClusterClientToServerTerminateKeyEstablishment(statusCode, \ + waitTime, \ + keyEstablishmentSuite) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, \ + "uuv", \ + statusCode, \ + waitTime, \ + keyEstablishmentSuite); + + +/** @brief Command description for InitiateKeyEstablishmentResponse + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: InitiateKeyEstablishmentResponse + * @param requestedKeyEstablishmentSuite uint16_t + * @param ephemeralDataGenerateTime uint8_t + * @param confirmKeyGenerateTime uint8_t + * @param identity uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentResponse(requestedKeyEstablishmentSuite, \ + ephemeralDataGenerateTime, \ + confirmKeyGenerateTime, \ + identity) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_INITIATE_KEY_ESTABLISHMENT_RESPONSE_COMMAND_ID, \ + "vuub", \ + requestedKeyEstablishmentSuite, \ + ephemeralDataGenerateTime, \ + confirmKeyGenerateTime, \ + identity, \ + 48); + + +/** @brief Command description for EphemeralDataResponse + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: EphemeralDataResponse + * @param ephemeralData uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataResponse(ephemeralData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID, \ + "b", \ + ephemeralData, \ + 22); + + +/** @brief Command description for ConfirmKeyDataResponse + * + * Cluster: Key Establishment, Key Establishment cluster + * Command: ConfirmKeyDataResponse + * @param secureMessageAuthenticationCode uint8_t* + */ +#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataResponse(secureMessageAuthenticationCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ + ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID, \ + "G", \ + secureMessageAuthenticationCode); + + +/** @} END Key Establishment Commands */ + + +/** @name Information Commands */ +// @{ +/** @brief Command description for RequestInformation + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: RequestInformation + * @param inquiryId uint8_t + * @param dataTypeId uint8_t + * @param requestInformationPayload uint8_t* + * @param requestInformationPayloadLen uint16_t + */ +#define emberAfFillCommandInformationClusterRequestInformation(inquiryId, \ + dataTypeId, \ + requestInformationPayload, \ + requestInformationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_INFORMATION_COMMAND_ID, \ + "uub", \ + inquiryId, \ + dataTypeId, \ + requestInformationPayload, \ + requestInformationPayloadLen); + + +/** @brief Command description for PushInformationResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: PushInformationResponse + * @param notificationList uint8_t* + * @param notificationListLen uint16_t + */ +#define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, \ + notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, \ + "b", \ + notificationList, \ + notificationListLen); + + +/** @brief Command description for SendPreference + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: SendPreference + * @param preferenceType uint16_t + * @param preferencePayload uint8_t* + * @param preferencePayloadLen uint16_t + */ +#define emberAfFillCommandInformationClusterSendPreference(preferenceType, \ + preferencePayload, \ + preferencePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SEND_PREFERENCE_COMMAND_ID, \ + "vb", \ + preferenceType, \ + preferencePayload, \ + preferencePayloadLen); + + +/** @brief Command description for RequestPreferenceResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: RequestPreferenceResponse + * @param statusFeedback uint8_t + * @param preferenceType uint16_t + * @param preferencePayload uint8_t* + * @param preferencePayloadLen uint16_t + */ +#define emberAfFillCommandInformationClusterRequestPreferenceResponse(statusFeedback, \ + preferenceType, \ + preferencePayload, \ + preferencePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID, \ + "uvb", \ + statusFeedback, \ + preferenceType, \ + preferencePayload, \ + preferencePayloadLen); + + +/** @brief Command description for Update + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: Update + * @param accessControl uint8_t + * @param option uint8_t + * @param contents uint8_t* + * @param contentsLen uint16_t + */ +#define emberAfFillCommandInformationClusterUpdate(accessControl, \ + option, \ + contents, \ + contentsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_UPDATE_COMMAND_ID, \ + "uub", \ + accessControl, \ + option, \ + contents, \ + contentsLen); + + +/** @brief Command description for Delete + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: Delete + * @param deletionOptions uint8_t + * @param contentIds uint8_t* + * @param contentIdsLen uint16_t + */ +#define emberAfFillCommandInformationClusterDelete(deletionOptions, \ + contentIds, \ + contentIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_DELETE_COMMAND_ID, \ + "ub", \ + deletionOptions, \ + contentIds, \ + contentIdsLen); + + +/** @brief Command description for ConfigureNodeDescription + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: ConfigureNodeDescription + * @param description uint8_t* + */ +#define emberAfFillCommandInformationClusterConfigureNodeDescription(description) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, \ + "s", \ + description); + + +/** @brief Command description for ConfigureDeliveryEnable + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: ConfigureDeliveryEnable + * @param enable uint8_t + */ +#define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, \ + "u", \ + enable); + + +/** @brief Command description for ConfigurePushInformationTimer + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: ConfigurePushInformationTimer + * @param timer uint32_t + */ +#define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, \ + "w", \ + timer); + + +/** @brief Command description for ConfigureSetRootId + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: ConfigureSetRootId + * @param rootId uint16_t + */ +#define emberAfFillCommandInformationClusterConfigureSetRootId(rootId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, \ + "v", \ + rootId); + + +/** @brief Command description for RequestInformationResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: RequestInformationResponse + * @param number uint8_t + * @param buffer uint8_t* + * @param bufferLen uint16_t + */ +#define emberAfFillCommandInformationClusterRequestInformationResponse(number, \ + buffer, \ + bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID, \ + "ub", \ + number, \ + buffer, \ + bufferLen); + + +/** @brief Command description for PushInformation + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: PushInformation + * @param contents uint8_t* + * @param contentsLen uint16_t + */ +#define emberAfFillCommandInformationClusterPushInformation(contents, \ + contentsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_PUSH_INFORMATION_COMMAND_ID, \ + "b", \ + contents, \ + contentsLen); + + +/** @brief Command description for SendPreferenceResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: SendPreferenceResponse + * @param statusFeedbackList uint8_t* + * @param statusFeedbackListLen uint16_t + */ +#define emberAfFillCommandInformationClusterSendPreferenceResponse(statusFeedbackList, \ + statusFeedbackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID, \ + "b", \ + statusFeedbackList, \ + statusFeedbackListLen); + + +/** @brief Command description for ServerRequestPreference + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: ServerRequestPreference + */ +#define emberAfFillCommandInformationClusterServerRequestPreference() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, \ + ""); + + +/** @brief Command description for RequestPreferenceConfirmation + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: RequestPreferenceConfirmation + * @param statusFeedbackList uint8_t* + * @param statusFeedbackListLen uint16_t + */ +#define emberAfFillCommandInformationClusterRequestPreferenceConfirmation(statusFeedbackList, \ + statusFeedbackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_PREFERENCE_CONFIRMATION_COMMAND_ID, \ + "b", \ + statusFeedbackList, \ + statusFeedbackListLen); + + +/** @brief Command description for UpdateResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: UpdateResponse + * @param notificationList uint8_t* + * @param notificationListLen uint16_t + */ +#define emberAfFillCommandInformationClusterUpdateResponse(notificationList, \ + notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_UPDATE_RESPONSE_COMMAND_ID, \ + "b", \ + notificationList, \ + notificationListLen); + + +/** @brief Command description for DeleteResponse + * + * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. + * Command: DeleteResponse + * @param notificationList uint8_t* + * @param notificationListLen uint16_t + */ +#define emberAfFillCommandInformationClusterDeleteResponse(notificationList, \ + notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_DELETE_RESPONSE_COMMAND_ID, \ + "b", \ + notificationList, \ + notificationListLen); + + +/** @} END Information Commands */ + + +/** @name Data Sharing Commands */ +// @{ +/** @brief Command description for ReadFileRequest + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: ReadFileRequest + * @param fileIndex uint16_t + * @param fileStartPositionAndRequestedOctetCount uint8_t* + * @param fileStartPositionAndRequestedOctetCountLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterReadFileRequest(fileIndex, \ + fileStartPositionAndRequestedOctetCount, \ + fileStartPositionAndRequestedOctetCountLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_READ_FILE_REQUEST_COMMAND_ID, \ + "vb", \ + fileIndex, \ + fileStartPositionAndRequestedOctetCount, \ + fileStartPositionAndRequestedOctetCountLen); + + +/** @brief Command description for ReadRecordRequest + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: ReadRecordRequest + * @param fileIndex uint16_t + * @param fileStartRecordAndRequestedRecordCount uint8_t* + * @param fileStartRecordAndRequestedRecordCountLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterReadRecordRequest(fileIndex, \ + fileStartRecordAndRequestedRecordCount, \ + fileStartRecordAndRequestedRecordCountLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_READ_RECORD_REQUEST_COMMAND_ID, \ + "vb", \ + fileIndex, \ + fileStartRecordAndRequestedRecordCount, \ + fileStartRecordAndRequestedRecordCountLen); + + +/** @brief Command description for WriteFileResponse + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: WriteFileResponse + * @param status uint8_t + * @param fileIndex uint8_t* + * @param fileIndexLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterWriteFileResponse(status, \ + fileIndex, \ + fileIndexLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, \ + "ub", \ + status, \ + fileIndex, \ + fileIndexLen); + + +/** @brief Command description for WriteFileRequest + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: WriteFileRequest + * @param writeOptions uint8_t + * @param fileSize uint8_t* + * @param fileSizeLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterWriteFileRequest(writeOptions, \ + fileSize, \ + fileSizeLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_WRITE_FILE_REQUEST_COMMAND_ID, \ + "ub", \ + writeOptions, \ + fileSize, \ + fileSizeLen); + + +/** @brief Command description for ModifyFileRequest + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: ModifyFileRequest + * @param fileIndex uint16_t + * @param fileStartPosition uint32_t + * @param octetCount uint32_t + */ +#define emberAfFillCommandDataSharingClusterModifyFileRequest(fileIndex, \ + fileStartPosition, \ + octetCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_MODIFY_FILE_REQUEST_COMMAND_ID, \ + "vww", \ + fileIndex, \ + fileStartPosition, \ + octetCount); + + +/** @brief Command description for ModifyRecordRequest + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: ModifyRecordRequest + * @param fileIndex uint16_t + * @param fileStartRecord uint16_t + * @param recordCount uint16_t + */ +#define emberAfFillCommandDataSharingClusterModifyRecordRequest(fileIndex, \ + fileStartRecord, \ + recordCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_MODIFY_RECORD_REQUEST_COMMAND_ID, \ + "vvv", \ + fileIndex, \ + fileStartRecord, \ + recordCount); + + +/** @brief Command description for FileTransmission + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: FileTransmission + * @param transmitOptions uint8_t + * @param buffer uint8_t* + * @param bufferLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterFileTransmission(transmitOptions, \ + buffer, \ + bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_FILE_TRANSMISSION_COMMAND_ID, \ + "ub", \ + transmitOptions, \ + buffer, \ + bufferLen); + + +/** @brief Command description for RecordTransmission + * + * Cluster: Data Sharing, Commands and attributes for small data sharing among ZigBee devices. + * Command: RecordTransmission + * @param transmitOptions uint8_t + * @param buffer uint8_t* + * @param bufferLen uint16_t + */ +#define emberAfFillCommandDataSharingClusterRecordTransmission(transmitOptions, \ + buffer, \ + bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_RECORD_TRANSMISSION_COMMAND_ID, \ + "ub", \ + transmitOptions, \ + buffer, \ + bufferLen); + + +/** @} END Data Sharing Commands */ + + +/** @name Gaming Commands */ +// @{ +/** @brief Command description for SearchGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: SearchGame + * @param specificGame uint8_t + * @param gameId uint16_t + */ +#define emberAfFillCommandGamingClusterSearchGame(specificGame, \ + gameId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_SEARCH_GAME_COMMAND_ID, \ + "uv", \ + specificGame, \ + gameId); + + +/** @brief Command description for JoinGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: JoinGame + * @param gameId uint16_t + * @param joinAsMaster uint8_t + * @param nameOfGame uint8_t* + */ +#define emberAfFillCommandGamingClusterJoinGame(gameId, \ + joinAsMaster, \ + nameOfGame) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_JOIN_GAME_COMMAND_ID, \ + "vus", \ + gameId, \ + joinAsMaster, \ + nameOfGame); + + +/** @brief Command description for StartGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: StartGame + */ +#define emberAfFillCommandGamingClusterStartGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_START_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for PauseGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: PauseGame + */ +#define emberAfFillCommandGamingClusterPauseGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_PAUSE_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for ResumeGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: ResumeGame + */ +#define emberAfFillCommandGamingClusterResumeGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_RESUME_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for QuitGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: QuitGame + */ +#define emberAfFillCommandGamingClusterQuitGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_QUIT_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for EndGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: EndGame + */ +#define emberAfFillCommandGamingClusterEndGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_END_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for StartOver + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: StartOver + */ +#define emberAfFillCommandGamingClusterStartOver() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_START_OVER_COMMAND_ID, \ + ""); + + +/** @brief Command description for ActionControl + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: ActionControl + * @param actions uint32_t + */ +#define emberAfFillCommandGamingClusterActionControl(actions) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_ACTION_CONTROL_COMMAND_ID, \ + "w", \ + actions); + + +/** @brief Command description for DownloadGame + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: DownloadGame + */ +#define emberAfFillCommandGamingClusterDownloadGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_DOWNLOAD_GAME_COMMAND_ID, \ + ""); + + +/** @brief Command description for GameAnnouncement + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: GameAnnouncement + * @param gameId uint16_t + * @param gameMaster uint8_t + * @param listOfGame uint8_t* + */ +#define emberAfFillCommandGamingClusterGameAnnouncement(gameId, \ + gameMaster, \ + listOfGame) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_GAME_ANNOUNCEMENT_COMMAND_ID, \ + "vus", \ + gameId, \ + gameMaster, \ + listOfGame); + + +/** @brief Command description for GeneralResponse + * + * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. + * Command: GeneralResponse + * @param commandId uint8_t + * @param status uint8_t + * @param message uint8_t* + */ +#define emberAfFillCommandGamingClusterGeneralResponse(commandId, \ + status, \ + message) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_GAMING_CLUSTER_ID, \ + ZCL_GENERAL_RESPONSE_COMMAND_ID, \ + "uus", \ + commandId, \ + status, \ + message); + + +/** @} END Gaming Commands */ + + +/** @name Data Rate Control Commands */ +// @{ +/** @brief Command description for PathCreation + * + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. + * Command: PathCreation + * @param originatorAddress uint16_t + * @param destinationAddress uint16_t + * @param dataRate uint8_t + */ +#define emberAfFillCommandDataRateControlClusterPathCreation(originatorAddress, \ + destinationAddress, \ + dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ + ZCL_PATH_CREATION_COMMAND_ID, \ + "vvu", \ + originatorAddress, \ + destinationAddress, \ + dataRate); + + +/** @brief Command description for DataRateNotification + * + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. + * Command: DataRateNotification + * @param originatorAddress uint16_t + * @param destinationAddress uint16_t + * @param dataRate uint8_t + */ +#define emberAfFillCommandDataRateControlClusterDataRateNotification(originatorAddress, \ + destinationAddress, \ + dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ + ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, \ + "vvu", \ + originatorAddress, \ + destinationAddress, \ + dataRate); + + +/** @brief Command description for PathDeletion + * + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. + * Command: PathDeletion + * @param originatorAddress uint16_t + * @param destinationAddress uint16_t + */ +#define emberAfFillCommandDataRateControlClusterPathDeletion(originatorAddress, \ + destinationAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ + ZCL_PATH_DELETION_COMMAND_ID, \ + "vv", \ + originatorAddress, \ + destinationAddress); + + +/** @brief Command description for DataRateControl + * + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. + * Command: DataRateControl + * @param originatorAddress uint16_t + * @param destinationAddress uint16_t + * @param dataRate uint8_t + */ +#define emberAfFillCommandDataRateControlClusterDataRateControl(originatorAddress, \ + destinationAddress, \ + dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ + ZCL_DATA_RATE_CONTROL_COMMAND_ID, \ + "vvu", \ + originatorAddress, \ + destinationAddress, \ + dataRate); + + +/** @} END Data Rate Control Commands */ + + +/** @name Voice over ZigBee Commands */ +// @{ +/** @brief Command description for EstablishmentRequest + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: EstablishmentRequest + * @param flag uint8_t + * @param codecType uint8_t + * @param sampFreq uint8_t + * @param codecRate uint8_t + * @param serviceType uint8_t + * @param buffer uint8_t* + * @param bufferLen uint16_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentRequest(flag, \ + codecType, \ + sampFreq, \ + codecRate, \ + serviceType, \ + buffer, \ + bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, \ + "uuuuub", \ + flag, \ + codecType, \ + sampFreq, \ + codecRate, \ + serviceType, \ + buffer, \ + bufferLen); + + +/** @brief Command description for VoiceTransmission + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: VoiceTransmission + * @param voiceData uint8_t* + * @param voiceDataLen uint16_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmission(voiceData, \ + voiceDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_VOICE_TRANSMISSION_COMMAND_ID, \ + "b", \ + voiceData, \ + voiceDataLen); + + +/** @brief Command description for VoiceTransmissionCompletion + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: VoiceTransmissionCompletion + */ +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionCompletion() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, \ + ""); + + +/** @brief Command description for ControlResponse + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: ControlResponse + * @param ackNack uint8_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterControlResponse(ackNack) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_CONTROL_RESPONSE_COMMAND_ID, \ + "u", \ + ackNack); + + +/** @brief Command description for EstablishmentResponse + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: EstablishmentResponse + * @param ackNack uint8_t + * @param codecType uint8_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentResponse(ackNack, \ + codecType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID, \ + "uu", \ + ackNack, \ + codecType); + + +/** @brief Command description for VoiceTransmissionResponse + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: VoiceTransmissionResponse + * @param sequenceNumber uint8_t + * @param errorFlag uint8_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionResponse(sequenceNumber, \ + errorFlag) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_VOICE_TRANSMISSION_RESPONSE_COMMAND_ID, \ + "uu", \ + sequenceNumber, \ + errorFlag); + + +/** @brief Command description for Control + * + * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. + * Command: Control + * @param controlType uint8_t + */ +#define emberAfFillCommandVoiceOverZigbeeClusterControl(controlType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ + ZCL_CONTROL_COMMAND_ID, \ + "u", \ + controlType); + + +/** @} END Voice over ZigBee Commands */ + + +/** @name Chatting Commands */ +// @{ +/** @brief Command description for JoinChatRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: JoinChatRequest + * @param uid uint16_t + * @param nickname uint8_t* + * @param cid uint16_t + */ +#define emberAfFillCommandChattingClusterJoinChatRequest(uid, \ + nickname, \ + cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, \ + "vsv", \ + uid, \ + nickname, \ + cid); + + +/** @brief Command description for LeaveChatRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: LeaveChatRequest + * @param cid uint16_t + * @param uid uint16_t + */ +#define emberAfFillCommandChattingClusterLeaveChatRequest(cid, \ + uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, \ + "vv", \ + cid, \ + uid); + + +/** @brief Command description for SearchChatRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SearchChatRequest + */ +#define emberAfFillCommandChattingClusterSearchChatRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, \ + ""); + + +/** @brief Command description for SwitchChairmanResponse + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SwitchChairmanResponse + * @param cid uint16_t + * @param uid uint16_t + */ +#define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, \ + uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, \ + "vv", \ + cid, \ + uid); + + +/** @brief Command description for StartChatRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: StartChatRequest + * @param name uint8_t* + * @param uid uint16_t + * @param nickname uint8_t* + */ +#define emberAfFillCommandChattingClusterStartChatRequest(name, \ + uid, \ + nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_START_CHAT_REQUEST_COMMAND_ID, \ + "svs", \ + name, \ + uid, \ + nickname); + + +/** @brief Command description for ChatMessage + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: ChatMessage + * @param destinationUid uint16_t + * @param sourceUid uint16_t + * @param cid uint16_t + * @param nickname uint8_t* + * @param message uint8_t* + */ +#define emberAfFillCommandChattingClusterChatMessage(destinationUid, \ + sourceUid, \ + cid, \ + nickname, \ + message) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_CHAT_MESSAGE_COMMAND_ID, \ + "vvvss", \ + destinationUid, \ + sourceUid, \ + cid, \ + nickname, \ + message); + + +/** @brief Command description for GetNodeInformationRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: GetNodeInformationRequest + * @param cid uint16_t + * @param uid uint16_t + */ +#define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, \ + uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, \ + "vv", \ + cid, \ + uid); + + +/** @brief Command description for StartChatResponse + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: StartChatResponse + * @param status uint8_t + * @param cid uint16_t + */ +#define emberAfFillCommandChattingClusterStartChatResponse(status, \ + cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_START_CHAT_RESPONSE_COMMAND_ID, \ + "uv", \ + status, \ + cid); + + +/** @brief Command description for JoinChatResponse + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: JoinChatResponse + * @param status uint8_t + * @param cid uint16_t + * @param chatParticipantList uint8_t* + * @param chatParticipantListLen uint16_t + */ +#define emberAfFillCommandChattingClusterJoinChatResponse(status, \ + cid, \ + chatParticipantList, \ + chatParticipantListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID, \ + "uvb", \ + status, \ + cid, \ + chatParticipantList, \ + chatParticipantListLen); + + +/** @brief Command description for UserLeft + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: UserLeft + * @param cid uint16_t + * @param uid uint16_t + * @param nickname uint8_t* + */ +#define emberAfFillCommandChattingClusterUserLeft(cid, \ + uid, \ + nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_USER_LEFT_COMMAND_ID, \ + "vvs", \ + cid, \ + uid, \ + nickname); + + +/** @brief Command description for UserJoined + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: UserJoined + * @param cid uint16_t + * @param uid uint16_t + * @param nickname uint8_t* + */ +#define emberAfFillCommandChattingClusterUserJoined(cid, \ + uid, \ + nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_USER_JOINED_COMMAND_ID, \ + "vvs", \ + cid, \ + uid, \ + nickname); + + +/** @brief Command description for SearchChatResponse + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SearchChatResponse + * @param options uint8_t + * @param chatRoomList uint8_t* + * @param chatRoomListLen uint16_t + */ +#define emberAfFillCommandChattingClusterSearchChatResponse(options, \ + chatRoomList, \ + chatRoomListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID, \ + "ub", \ + options, \ + chatRoomList, \ + chatRoomListLen); + + +/** @brief Command description for SwitchChairmanRequest + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SwitchChairmanRequest + * @param cid uint16_t + */ +#define emberAfFillCommandChattingClusterSwitchChairmanRequest(cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID, \ + "v", \ + cid); + + +/** @brief Command description for SwitchChairmanConfirm + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SwitchChairmanConfirm + * @param cid uint16_t + * @param nodeInformationList uint8_t* + * @param nodeInformationListLen uint16_t + */ +#define emberAfFillCommandChattingClusterSwitchChairmanConfirm(cid, \ + nodeInformationList, \ + nodeInformationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID, \ + "vb", \ + cid, \ + nodeInformationList, \ + nodeInformationListLen); + + +/** @brief Command description for SwitchChairmanNotification + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: SwitchChairmanNotification + * @param cid uint16_t + * @param uid uint16_t + * @param address uint16_t + * @param endpoint uint8_t + */ +#define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, \ + uid, \ + address, \ + endpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, \ + "vvvu", \ + cid, \ + uid, \ + address, \ + endpoint); + + +/** @brief Command description for GetNodeInformationResponse + * + * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. + * Command: GetNodeInformationResponse + * @param status uint8_t + * @param cid uint16_t + * @param uid uint16_t + * @param addressEndpointAndNickname uint8_t* + * @param addressEndpointAndNicknameLen uint16_t + */ +#define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, \ + cid, \ + uid, \ + addressEndpointAndNickname, \ + addressEndpointAndNicknameLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_CHATTING_CLUSTER_ID, \ + ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, \ + "uvvb", \ + status, \ + cid, \ + uid, \ + addressEndpointAndNickname, \ + addressEndpointAndNicknameLen); + + +/** @} END Chatting Commands */ + + +/** @name Payment Commands */ +// @{ +/** @brief Command description for BuyRequest + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: BuyRequest + * @param userId uint8_t* + * @param userType uint16_t + * @param serviceId uint16_t + * @param goodId uint8_t* + */ +#define emberAfFillCommandPaymentClusterBuyRequest(userId, \ + userType, \ + serviceId, \ + goodId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_BUY_REQUEST_COMMAND_ID, \ + "svvs", \ + userId, \ + userType, \ + serviceId, \ + goodId); + + +/** @brief Command description for AcceptPayment + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: AcceptPayment + * @param userId uint8_t* + * @param userType uint16_t + * @param serviceId uint16_t + * @param goodId uint8_t* + */ +#define emberAfFillCommandPaymentClusterAcceptPayment(userId, \ + userType, \ + serviceId, \ + goodId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_ACCEPT_PAYMENT_COMMAND_ID, \ + "svvs", \ + userId, \ + userType, \ + serviceId, \ + goodId); + + +/** @brief Command description for PaymentConfirm + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: PaymentConfirm + * @param serialNumber uint8_t* + * @param transId uint16_t + * @param transStatus uint8_t + */ +#define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, \ + transId, \ + transStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_PAYMENT_CONFIRM_COMMAND_ID, \ + "svu", \ + serialNumber, \ + transId, \ + transStatus); + + +/** @brief Command description for BuyConfirm + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: BuyConfirm + * @param serialNumber uint8_t* + * @param currency uint32_t + * @param priceTrailingDigit uint8_t + * @param price uint32_t + * @param timestamp uint8_t* + * @param transId uint16_t + * @param transStatus uint8_t + */ +#define emberAfFillCommandPaymentClusterBuyConfirm(serialNumber, \ + currency, \ + priceTrailingDigit, \ + price, \ + timestamp, \ + transId, \ + transStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_BUY_CONFIRM_COMMAND_ID, \ + "swuwsvu", \ + serialNumber, \ + currency, \ + priceTrailingDigit, \ + price, \ + timestamp, \ + transId, \ + transStatus); + + +/** @brief Command description for ReceiptDelivery + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: ReceiptDelivery + * @param serialNumber uint8_t* + * @param currency uint32_t + * @param priceTrailingDigit uint8_t + * @param price uint32_t + * @param timestamp uint8_t* + */ +#define emberAfFillCommandPaymentClusterReceiptDelivery(serialNumber, \ + currency, \ + priceTrailingDigit, \ + price, \ + timestamp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_RECEIPT_DELIVERY_COMMAND_ID, \ + "swuws", \ + serialNumber, \ + currency, \ + priceTrailingDigit, \ + price, \ + timestamp); + + +/** @brief Command description for TransactionEnd + * + * Cluster: Payment, Commands and attributes for payment scenarios including ZigBee devices. + * Command: TransactionEnd + * @param serialNumber uint8_t* + * @param status uint8_t + */ +#define emberAfFillCommandPaymentClusterTransactionEnd(serialNumber, \ + status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_TRANSACTION_END_COMMAND_ID, \ + "su", \ + serialNumber, \ + status); + + +/** @} END Payment Commands */ + + +/** @name Billing Commands */ +// @{ +/** @brief Command description for Subscribe + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: Subscribe + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterSubscribe(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_SUBSCRIBE_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for Unsubscribe + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: Unsubscribe + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterUnsubscribe(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_UNSUBSCRIBE_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for StartBillingSession + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: StartBillingSession + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterStartBillingSession(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_START_BILLING_SESSION_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for StopBillingSession + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: StopBillingSession + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterStopBillingSession(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_STOP_BILLING_SESSION_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for BillStatusNotification + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: BillStatusNotification + * @param userId uint8_t* + * @param status uint8_t + */ +#define emberAfFillCommandBillingClusterBillStatusNotification(userId, \ + status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, \ + "su", \ + userId, \ + status); + + +/** @brief Command description for SessionKeepAlive + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: SessionKeepAlive + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterSessionKeepAlive(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for CheckBillStatus + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: CheckBillStatus + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + */ +#define emberAfFillCommandBillingClusterCheckBillStatus(userId, \ + serviceId, \ + serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_CHECK_BILL_STATUS_COMMAND_ID, \ + "svv", \ + userId, \ + serviceId, \ + serviceProviderId); + + +/** @brief Command description for SendBillRecord + * + * Cluster: Billing, Attributes and commands to enable billing of users for provided services through the use of a billing platform. + * Command: SendBillRecord + * @param userId uint8_t* + * @param serviceId uint16_t + * @param serviceProviderId uint16_t + * @param timestamp uint8_t* + * @param duration uint16_t + */ +#define emberAfFillCommandBillingClusterSendBillRecord(userId, \ + serviceId, \ + serviceProviderId, \ + timestamp, \ + duration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_BILLING_CLUSTER_ID, \ + ZCL_SEND_BILL_RECORD_COMMAND_ID, \ + "svvsv", \ + userId, \ + serviceId, \ + serviceProviderId, \ + timestamp, \ + duration); + + +/** @} END Billing Commands */ + + +/** @name Appliance Identification Commands */ +// @{ +/** @} END Appliance Identification Commands */ + + +/** @name Meter Identification Commands */ +// @{ +/** @} END Meter Identification Commands */ + + +/** @name Appliance Events and Alert Commands */ +// @{ +/** @brief This basic message is used to retrieve Household Appliance current alerts. + * + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. + * Command: GetAlerts + */ +#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlerts() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ + ZCL_GET_ALERTS_COMMAND_ID, \ + ""); + + +/** @brief This message is used to return household appliance current alerts. + * + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. + * Command: GetAlertsResponse + * @param alertsCount uint8_t + * @param alertStructures uint8_t* + * @param alertStructuresLen uint16_t + */ +#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlertsResponse(alertsCount, \ + alertStructures, \ + alertStructuresLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ + ZCL_GET_ALERTS_RESPONSE_COMMAND_ID, \ + "ub", \ + alertsCount, \ + alertStructures, \ + alertStructuresLen); + + +/** @brief This message is used to notify the current modification of warning and/or fault conditions. + * + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. + * Command: AlertsNotification + * @param alertsCount uint8_t + * @param alertStructures uint8_t* + * @param alertStructuresLen uint16_t + */ +#define emberAfFillCommandApplianceEventsAndAlertClusterAlertsNotification(alertsCount, \ + alertStructures, \ + alertStructuresLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ + ZCL_ALERTS_NOTIFICATION_COMMAND_ID, \ + "ub", \ + alertsCount, \ + alertStructures, \ + alertStructuresLen); + + +/** @brief This message is used to notify an event occurred during the normal working of the appliance. + * + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. + * Command: EventsNotification + * @param eventHeader uint8_t + * @param eventId uint8_t + */ +#define emberAfFillCommandApplianceEventsAndAlertClusterEventsNotification(eventHeader, \ + eventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ + ZCL_EVENTS_NOTIFICATION_COMMAND_ID, \ + "uu", \ + eventHeader, \ + eventId); + + +/** @} END Appliance Events and Alert Commands */ + + +/** @name Appliance Statistics Commands */ +// @{ +/** @brief The Appliance Statistics Cluster server occasionally sends out a Log Notification command to the devices to which it needs to log information related to statistics (e.g., home gateways) which implement the client side of Appliance Statistics Cluster. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: LogNotification + * @param timeStamp uint32_t + * @param logId uint32_t + * @param logLength uint32_t + * @param logPayload uint8_t* + * @param logPayloadLen uint16_t + */ +#define emberAfFillCommandApplianceStatisticsClusterLogNotification(timeStamp, \ + logId, \ + logLength, \ + logPayload, \ + logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_LOG_NOTIFICATION_COMMAND_ID, \ + "wwwb", \ + timeStamp, \ + logId, \ + logLength, \ + logPayload, \ + logPayloadLen); + + +/** @brief The Appliance Statistics Cluster server sends out a Log Response command to respond to a Log Request command generated by the client side of the Appliance Statistics cluster. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: LogResponse + * @param timeStamp uint32_t + * @param logId uint32_t + * @param logLength uint32_t + * @param logPayload uint8_t* + * @param logPayloadLen uint16_t + */ +#define emberAfFillCommandApplianceStatisticsClusterLogResponse(timeStamp, \ + logId, \ + logLength, \ + logPayload, \ + logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_LOG_RESPONSE_COMMAND_ID, \ + "wwwb", \ + timeStamp, \ + logId, \ + logLength, \ + logPayload, \ + logPayloadLen); + + +/** @brief The Log Queue Response command is generated as a response to a LogQueueRequest command in order to notify the client side of the Appliance statistics cluster about the logs stored in the server side (queue) that can be retrieved by the client side of this cluster through a LogRequest command. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: LogQueueResponse + * @param logQueueSize uint8_t + * @param logIds uint8_t* + * @param logIdsLen uint16_t + */ +#define emberAfFillCommandApplianceStatisticsClusterLogQueueResponse(logQueueSize, \ + logIds, \ + logIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, \ + "ub", \ + logQueueSize, \ + logIds, \ + logIdsLen); + + +/** @brief The Appliance Statistics Cluster server sends out a Statistic Available command to notify the client side of the Appliance Statistics cluster that there are statistics that can be retrieved by using the Log Request command. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: StatisticsAvailable + * @param logQueueSize uint8_t + * @param logIds uint8_t* + * @param logIdsLen uint16_t + */ +#define emberAfFillCommandApplianceStatisticsClusterStatisticsAvailable(logQueueSize, \ + logIds, \ + logIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_STATISTICS_AVAILABLE_COMMAND_ID, \ + "ub", \ + logQueueSize, \ + logIds, \ + logIdsLen); + + +/** @brief The Log request command is sent from a device supporting the client side of the Appliance Statistics cluster (e.g., Home Gateway) to retrieve the log from the device supporting the server side (e.g., appliance). + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: LogRequest + * @param logId uint32_t + */ +#define emberAfFillCommandApplianceStatisticsClusterLogRequest(logId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_LOG_REQUEST_COMMAND_ID, \ + "w", \ + logId); + + +/** @brief The Log Queue Request command is send from a device supporting the client side of the Appliance Statistics cluster (e.g. Home Gateway) to retrieve the information about the logs inserted in the queue, from the device supporting the server side (e.g. appliance). + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. + * Command: LogQueueRequest + */ +#define emberAfFillCommandApplianceStatisticsClusterLogQueueRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ + ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, \ + ""); + + +/** @} END Appliance Statistics Commands */ + + +/** @name Electrical Measurement Commands */ +// @{ +/** @brief A function which returns the power profiling information requested in the GetProfileInfo command. The power profiling information consists of a list of attributes which are profiled along with the period used to profile them. + * + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. + * Command: GetProfileInfoResponseCommand + * @param profileCount uint8_t + * @param profileIntervalPeriod uint8_t + * @param maxNumberOfIntervals uint8_t + * @param listOfAttributes uint8_t* + * @param listOfAttributesLen uint16_t + */ +#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoResponseCommand(profileCount, \ + profileIntervalPeriod, \ + maxNumberOfIntervals, \ + listOfAttributes, \ + listOfAttributesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ + ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID, \ + "uuub", \ + profileCount, \ + profileIntervalPeriod, \ + maxNumberOfIntervals, \ + listOfAttributes, \ + listOfAttributesLen); + + +/** @brief A function which returns the electricity measurement profile. The electricity measurement profile includes information regarding the amount of time used to capture data related to the flow of electricity as well as the intervals thes + * + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. + * Command: GetMeasurementProfileResponseCommand + * @param startTime uint32_t + * @param status uint8_t + * @param profileIntervalPeriod uint8_t + * @param numberOfIntervalsDelivered uint8_t + * @param attributeId uint16_t + * @param intervals uint8_t* + * @param intervalsLen uint16_t + */ +#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileResponseCommand(startTime, \ + status, \ + profileIntervalPeriod, \ + numberOfIntervalsDelivered, \ + attributeId, \ + intervals, \ + intervalsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ + ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, \ + "wuuuvb", \ + startTime, \ + status, \ + profileIntervalPeriod, \ + numberOfIntervalsDelivered, \ + attributeId, \ + intervals, \ + intervalsLen); + + +/** @brief A function which retrieves the power profiling information from the electrical measurement server. + * + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. + * Command: GetProfileInfoCommand + */ +#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoCommand() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ + ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, \ + ""); + + +/** @brief A function which retrieves an electricity measurement profile from the electricity measurement server for a specific attribute Id requested. + * + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. + * Command: GetMeasurementProfileCommand + * @param attributeId uint16_t + * @param startTime uint32_t + * @param numberOfIntervals uint8_t + */ +#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileCommand(attributeId, \ + startTime, \ + numberOfIntervals) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ + ZCL_GET_MEASUREMENT_PROFILE_COMMAND_COMMAND_ID, \ + "vwu", \ + attributeId, \ + startTime, \ + numberOfIntervals); + + +/** @} END Electrical Measurement Commands */ + + +/** @name Diagnostics Commands */ +// @{ +/** @} END Diagnostics Commands */ + + +/** @name ZLL Commissioning Commands */ +// @{ +/** @brief Command description for ScanRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: ScanRequest + * @param transaction uint32_t + * @param zigbeeInformation uint8_t + * @param zllInformation uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterScanRequest(transaction, \ + zigbeeInformation, \ + zllInformation) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SCAN_REQUEST_COMMAND_ID, \ + "wuu", \ + transaction, \ + zigbeeInformation, \ + zllInformation); + + +/** @brief Command description for DeviceInformationRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: DeviceInformationRequest + * @param transaction uint32_t + * @param startIndex uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterDeviceInformationRequest(transaction, \ + startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, \ + "wu", \ + transaction, \ + startIndex); + + +/** @brief Command description for IdentifyRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: IdentifyRequest + * @param transaction uint32_t + * @param identifyDuration uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterIdentifyRequest(transaction, \ + identifyDuration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_IDENTIFY_REQUEST_COMMAND_ID, \ + "wv", \ + transaction, \ + identifyDuration); + + +/** @brief Command description for ResetToFactoryNewRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: ResetToFactoryNewRequest + * @param transaction uint32_t + */ +#define emberAfFillCommandZllCommissioningClusterResetToFactoryNewRequest(transaction) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, \ + "w", \ + transaction); + + +/** @brief Command description for NetworkStartRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkStartRequest + * @param transaction uint32_t + * @param extendedPanId uint8_t* + * @param keyIndex uint8_t + * @param encryptedNetworkKey uint8_t* + * @param logicalChannel uint8_t + * @param panId uint16_t + * @param networkAddress uint16_t + * @param groupIdentifiersBegin uint16_t + * @param groupIdentifiersEnd uint16_t + * @param freeNetworkAddressRangeBegin uint16_t + * @param freeNetworkAddressRangeEnd uint16_t + * @param freeGroupIdentifierRangeBegin uint16_t + * @param freeGroupIdentifierRangeEnd uint16_t + * @param initiatorIeeeAddress uint8_t* + * @param initiatorNetworkAddress uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkStartRequest(transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd, \ + initiatorIeeeAddress, \ + initiatorNetworkAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_START_REQUEST_COMMAND_ID, \ + "w8uGuvvvvvvvv8v", \ + transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd, \ + initiatorIeeeAddress, \ + initiatorNetworkAddress); + + +/** @brief Command description for NetworkJoinRouterRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkJoinRouterRequest + * @param transaction uint32_t + * @param extendedPanId uint8_t* + * @param keyIndex uint8_t + * @param encryptedNetworkKey uint8_t* + * @param networkUpdateId uint8_t + * @param logicalChannel uint8_t + * @param panId uint16_t + * @param networkAddress uint16_t + * @param groupIdentifiersBegin uint16_t + * @param groupIdentifiersEnd uint16_t + * @param freeNetworkAddressRangeBegin uint16_t + * @param freeNetworkAddressRangeEnd uint16_t + * @param freeGroupIdentifierRangeBegin uint16_t + * @param freeGroupIdentifierRangeEnd uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterRequest(transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, \ + "w8uGuuvvvvvvvv", \ + transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd); + + +/** @brief Command description for NetworkJoinEndDeviceRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkJoinEndDeviceRequest + * @param transaction uint32_t + * @param extendedPanId uint8_t* + * @param keyIndex uint8_t + * @param encryptedNetworkKey uint8_t* + * @param networkUpdateId uint8_t + * @param logicalChannel uint8_t + * @param panId uint16_t + * @param networkAddress uint16_t + * @param groupIdentifiersBegin uint16_t + * @param groupIdentifiersEnd uint16_t + * @param freeNetworkAddressRangeBegin uint16_t + * @param freeNetworkAddressRangeEnd uint16_t + * @param freeGroupIdentifierRangeBegin uint16_t + * @param freeGroupIdentifierRangeEnd uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceRequest(transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, \ + "w8uGuuvvvvvvvv", \ + transaction, \ + extendedPanId, \ + keyIndex, \ + encryptedNetworkKey, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + groupIdentifiersBegin, \ + groupIdentifiersEnd, \ + freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd); + + +/** @brief Command description for NetworkUpdateRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkUpdateRequest + * @param transaction uint32_t + * @param extendedPanId uint8_t* + * @param networkUpdateId uint8_t + * @param logicalChannel uint8_t + * @param panId uint16_t + * @param networkAddress uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkUpdateRequest(transaction, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, \ + "w8uuvv", \ + transaction, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress); + + +/** @brief Command description for GetGroupIdentifiersRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: GetGroupIdentifiersRequest + * @param startIndex uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, \ + "u", \ + startIndex); + + +/** @brief Command description for GetEndpointListRequest + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: GetEndpointListRequest + * @param startIndex uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterGetEndpointListRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, \ + "u", \ + startIndex); + + +/** @brief Command description for ScanResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: ScanResponse + * @param transaction uint32_t + * @param rssiCorrection uint8_t + * @param zigbeeInformation uint8_t + * @param zllInformation uint8_t + * @param keyBitmask uint16_t + * @param responseId uint32_t + * @param extendedPanId uint8_t* + * @param networkUpdateId uint8_t + * @param logicalChannel uint8_t + * @param panId uint16_t + * @param networkAddress uint16_t + * @param numberOfSubDevices uint8_t + * @param totalGroupIds uint8_t + * @param endpointId uint8_t + * @param profileId uint16_t + * @param deviceId uint16_t + * @param version uint8_t + * @param groupIdCount uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterScanResponse(transaction, \ + rssiCorrection, \ + zigbeeInformation, \ + zllInformation, \ + keyBitmask, \ + responseId, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + numberOfSubDevices, \ + totalGroupIds, \ + endpointId, \ + profileId, \ + deviceId, \ + version, \ + groupIdCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SCAN_RESPONSE_COMMAND_ID, \ + "wuuuvw8uuvvuuuvvuu", \ + transaction, \ + rssiCorrection, \ + zigbeeInformation, \ + zllInformation, \ + keyBitmask, \ + responseId, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId, \ + networkAddress, \ + numberOfSubDevices, \ + totalGroupIds, \ + endpointId, \ + profileId, \ + deviceId, \ + version, \ + groupIdCount); + + +/** @brief Command description for DeviceInformationResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: DeviceInformationResponse + * @param transaction uint32_t + * @param numberOfSubDevices uint8_t + * @param startIndex uint8_t + * @param deviceInformationRecordCount uint8_t + * @param deviceInformationRecordList uint8_t* + * @param deviceInformationRecordListLen uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterDeviceInformationResponse(transaction, \ + numberOfSubDevices, \ + startIndex, \ + deviceInformationRecordCount, \ + deviceInformationRecordList, \ + deviceInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, \ + "wuuub", \ + transaction, \ + numberOfSubDevices, \ + startIndex, \ + deviceInformationRecordCount, \ + deviceInformationRecordList, \ + deviceInformationRecordListLen); + + +/** @brief Command description for NetworkStartResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkStartResponse + * @param transaction uint32_t + * @param status uint8_t + * @param extendedPanId uint8_t* + * @param networkUpdateId uint8_t + * @param logicalChannel uint8_t + * @param panId uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkStartResponse(transaction, \ + status, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_START_RESPONSE_COMMAND_ID, \ + "wu8uuv", \ + transaction, \ + status, \ + extendedPanId, \ + networkUpdateId, \ + logicalChannel, \ + panId); + + +/** @brief Command description for NetworkJoinRouterResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkJoinRouterResponse + * @param transaction uint32_t + * @param status uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterResponse(transaction, \ + status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, \ + "wu", \ + transaction, \ + status); + + +/** @brief Command description for NetworkJoinEndDeviceResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: NetworkJoinEndDeviceResponse + * @param transaction uint32_t + * @param status uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceResponse(transaction, \ + status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, \ + "wu", \ + transaction, \ + status); + + +/** @brief Command description for EndpointInformation + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: EndpointInformation + * @param ieeeAddress uint8_t* + * @param networkAddress uint16_t + * @param endpointId uint8_t + * @param profileId uint16_t + * @param deviceId uint16_t + * @param version uint8_t + */ +#define emberAfFillCommandZllCommissioningClusterEndpointInformation(ieeeAddress, \ + networkAddress, \ + endpointId, \ + profileId, \ + deviceId, \ + version) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_ENDPOINT_INFORMATION_COMMAND_ID, \ + "8vuvvu", \ + ieeeAddress, \ + networkAddress, \ + endpointId, \ + profileId, \ + deviceId, \ + version); + + +/** @brief Command description for GetGroupIdentifiersResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: GetGroupIdentifiersResponse + * @param total uint8_t + * @param startIndex uint8_t + * @param count uint8_t + * @param groupInformationRecordList uint8_t* + * @param groupInformationRecordListLen uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersResponse(total, \ + startIndex, \ + count, \ + groupInformationRecordList, \ + groupInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID, \ + "uuub", \ + total, \ + startIndex, \ + count, \ + groupInformationRecordList, \ + groupInformationRecordListLen); + + +/** @brief Command description for GetEndpointListResponse + * + * Cluster: ZLL Commissioning, The ZLL commissioning cluster provides commands to support touch link commissioning. + * Command: GetEndpointListResponse + * @param total uint8_t + * @param startIndex uint8_t + * @param count uint8_t + * @param endpointInformationRecordList uint8_t* + * @param endpointInformationRecordListLen uint16_t + */ +#define emberAfFillCommandZllCommissioningClusterGetEndpointListResponse(total, \ + startIndex, \ + count, \ + endpointInformationRecordList, \ + endpointInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ + ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID, \ + "uuub", \ + total, \ + startIndex, \ + count, \ + endpointInformationRecordList, \ + endpointInformationRecordListLen); + + +/** @} END ZLL Commissioning Commands */ + + +/** @name Sample Mfg Specific Cluster Commands */ +// @{ +/** @brief A sample manufacturer specific command within the sample manufacturer specific + cluster. + * + * Cluster: Sample Mfg Specific Cluster, This cluster provides an example of how the Application + Framework can be extended to include manufacturer specific clusters. + * Command: CommandOne + * @param argOne uint8_t + */ +#define emberAfFillCommandSampleMfgSpecificClusterCommandOne(argOne) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, \ + 0x1002, \ + ZCL_COMMAND_ONE_COMMAND_ID, \ + "u", \ + argOne); + + +/** @} END Sample Mfg Specific Cluster Commands */ + + +/** @name Sample Mfg Specific Cluster 2 Commands */ +// @{ +/** @brief A sample manufacturer specific command within the sample manufacturer specific + cluster. + * + * Cluster: Sample Mfg Specific Cluster 2, This cluster provides an example of how the Application + Framework can be extended to include manufacturer specific clusters. + * Command: CommandTwo + * @param argOne uint8_t + */ +#define emberAfFillCommandSampleMfgSpecificCluster2CommandTwo(argOne) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, \ + 0x1049, \ + ZCL_COMMAND_TWO_COMMAND_ID, \ + "u", \ + argOne); + + +/** @} END Sample Mfg Specific Cluster 2 Commands */ + + +/** @name Configuration Cluster Commands */ +// @{ +/** @brief Command to write a token value over the air. + * + * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware + parameters. + * Command: SetToken + * @param token uint16_t + * @param data uint8_t* + */ +#define emberAfFillCommandOtaConfigurationClusterSetToken(token, \ + data) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ + 0x1002, \ + ZCL_SET_TOKEN_COMMAND_ID, \ + "vs", \ + token, \ + data); + + +/** @brief Command to lock the token values. + * + * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware + parameters. + * Command: LockTokens + */ +#define emberAfFillCommandOtaConfigurationClusterLockTokens() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ + 0x1002, \ + ZCL_LOCK_TOKENS_COMMAND_ID, \ + ""); + + +/** @brief Command to read a token value. + * + * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware + parameters. + * Command: ReadTokens + * @param token uint16_t + */ +#define emberAfFillCommandOtaConfigurationClusterReadTokens(token) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ + 0x1002, \ + ZCL_READ_TOKENS_COMMAND_ID, \ + "v", \ + token); + + +/** @brief Command to unlock tokens with a device-specific password (if allowed). + * + * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware + parameters. + * Command: UnlockTokens + * @param data uint8_t* + */ +#define emberAfFillCommandOtaConfigurationClusterUnlockTokens(data) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ + 0x1002, \ + ZCL_UNLOCK_TOKENS_COMMAND_ID, \ + "s", \ + data); + + +/** @brief Response to a token value read. + * + * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware + parameters. + * Command: ReturnToken + * @param token uint16_t + * @param data uint8_t* + */ +#define emberAfFillCommandOtaConfigurationClusterReturnToken(token, \ + data) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ + 0x1002, \ + ZCL_RETURN_TOKEN_COMMAND_ID, \ + "vs", \ + token, \ + data); + + +/** @} END Configuration Cluster Commands */ + + +/** @name MFGLIB Cluster Commands */ +// @{ +/** @brief Command to put the device into streaming mode. + * + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. + * Command: stream + * @param channel uint8_t + * @param power int8_t + * @param time uint16_t + */ +#define emberAfFillCommandMfglibClusterstream(channel, \ + power, \ + time) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, \ + 0x1002, \ + ZCL_STREAM_COMMAND_ID, \ + "uuv", \ + channel, \ + power, \ + time); + + +/** @brief Command to put the device into tone mode. + * + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. + * Command: tone + * @param channel uint8_t + * @param power int8_t + * @param time uint16_t + */ +#define emberAfFillCommandMfglibClustertone(channel, \ + power, \ + time) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, \ + 0x1002, \ + ZCL_TONE_COMMAND_ID, \ + "uuv", \ + channel, \ + power, \ + time); + + +/** @brief Command to put the device into RX mode. + * + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. + * Command: rxMode + * @param channel uint8_t + * @param power int8_t + * @param time uint16_t + */ +#define emberAfFillCommandMfglibClusterrxMode(channel, \ + power, \ + time) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, \ + 0x1002, \ + ZCL_RX_MODE_COMMAND_ID, \ + "uuv", \ + channel, \ + power, \ + time); + + +/** @} END MFGLIB Cluster Commands */ + + +/** @name SL Works With All Hubs Commands */ +// @{ +/** @brief Enable enforcement of APS-level security for all cluster commands. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableApsLinkKeyAuthorization + * @param numberExemptClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterEnableApsLinkKeyAuthorization(numberExemptClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, \ + "ub", \ + numberExemptClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Disable enforcement of APS-level security for all cluster commands. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableApsLinkKeyAuthorization + * @param numberExemptClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterDisableApsLinkKeyAuthorization(numberExemptClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, \ + "ub", \ + numberExemptClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Query status of APS-level security enforcement for a specified cluster. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ApsLinkKeyAuthorizationQuery + * @param clusterId uint16_t + */ +#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQuery(clusterId) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID, \ + "v", \ + clusterId); + + +/** @brief Trigger device to request a new APS link key from the Trust Center. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: RequestNewApsLinkKey + */ +#define emberAfFillCommandSlWwahClusterRequestNewApsLinkKey() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID, \ + ""); + + +/** @brief Enable WWAH App Event retry algorithm. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableWwahAppEventRetryAlgorithm + * @param firstBackoffTimeSeconds uint8_t + * @param backoffSeqCommonRatio uint8_t + * @param maxBackoffTimeSeconds uint32_t + * @param maxRedeliveryAttempts uint8_t + */ +#define emberAfFillCommandSlWwahClusterEnableWwahAppEventRetryAlgorithm(firstBackoffTimeSeconds, \ + backoffSeqCommonRatio, \ + maxBackoffTimeSeconds, \ + maxRedeliveryAttempts) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, \ + "uuwu", \ + firstBackoffTimeSeconds, \ + backoffSeqCommonRatio, \ + maxBackoffTimeSeconds, \ + maxRedeliveryAttempts); + + +/** @brief Disable WWAH App Event retry algorithm. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableWwahAppEventRetryAlgorithm + */ +#define emberAfFillCommandSlWwahClusterDisableWwahAppEventRetryAlgorithm() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, \ + ""); + + +/** @brief Trigger device to request current attribute values from Time Cluster server. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: RequestTime + */ +#define emberAfFillCommandSlWwahClusterRequestTime() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_REQUEST_TIME_COMMAND_ID, \ + ""); + + +/** @brief Enable WWAH rejoin algorithm. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableWwahRejoinAlgorithm + * @param fastRejoinTimeoutSeconds uint16_t + * @param durationBetweenRejoinsSeconds uint16_t + * @param fastRejoinFirstBackoffSeconds uint16_t + * @param maxBackoffTimeSeconds uint16_t + * @param maxBackoffIterations uint16_t + */ +#define emberAfFillCommandSlWwahClusterEnableWwahRejoinAlgorithm(fastRejoinTimeoutSeconds, \ + durationBetweenRejoinsSeconds, \ + fastRejoinFirstBackoffSeconds, \ + maxBackoffTimeSeconds, \ + maxBackoffIterations) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, \ + "vvvvv", \ + fastRejoinTimeoutSeconds, \ + durationBetweenRejoinsSeconds, \ + fastRejoinFirstBackoffSeconds, \ + maxBackoffTimeSeconds, \ + maxBackoffIterations); + + +/** @brief Disable WWAH rejoin algorithm. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableWwahRejoinAlgorithm + */ +#define emberAfFillCommandSlWwahClusterDisableWwahRejoinAlgorithm() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, \ + ""); + + +/** @brief Set the enrollment method of an IAS Zone server. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: SetIasZoneEnrollmentMethod + * @param enrollmentMode uint8_t + */ +#define emberAfFillCommandSlWwahClusterSetIasZoneEnrollmentMethod(enrollmentMode) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID, \ + "u", \ + enrollmentMode); + + +/** @brief Clear the binding table. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ClearBindingTable + */ +#define emberAfFillCommandSlWwahClusterClearBindingTable() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_CLEAR_BINDING_TABLE_COMMAND_ID, \ + ""); + + +/** @brief Enable device to periodically check connectivity with Zigbee Coordinator. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnablePeriodicRouterCheckIns + * @param checkInInterval uint16_t + */ +#define emberAfFillCommandSlWwahClusterEnablePeriodicRouterCheckIns(checkInInterval) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, \ + "v", \ + checkInInterval); + + +/** @brief Disable device from periodically checking connectivity with Zigbee Coordinator. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisablePeriodicRouterCheckIns + */ +#define emberAfFillCommandSlWwahClusterDisablePeriodicRouterCheckIns() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, \ + ""); + + +/** @brief Set MAC poll failure wait time. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: SetMacPollFailureWaitTime + * @param waitTime uint8_t + */ +#define emberAfFillCommandSlWwahClusterSetMacPollFailureWaitTime(waitTime) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID, \ + "u", \ + waitTime); + + +/** @brief Set pending network update parameters. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: SetPendingNetworkUpdate + * @param channel uint8_t + * @param panId uint16_t + */ +#define emberAfFillCommandSlWwahClusterSetPendingNetworkUpdate(channel, \ + panId) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID, \ + "uv", \ + channel, \ + panId); + + +/** @brief Require all unicast commands to have APS ACKs enabled. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: RequireApsAcksOnUnicasts + * @param numberExemptClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterRequireApsAcksOnUnicasts(numberExemptClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID, \ + "ub", \ + numberExemptClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Roll back changes made by Require APS ACK on Unicasts. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: RemoveApsAcksOnUnicastsRequirement + */ +#define emberAfFillCommandSlWwahClusterRemoveApsAcksOnUnicastsRequirement() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID, \ + ""); + + +/** @brief Query whether unicast commands are required to have APS ACKs enabled. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ApsAckRequirementQuery + */ +#define emberAfFillCommandSlWwahClusterApsAckRequirementQuery() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID, \ + ""); + + +/** @brief Query for specified debug report. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DebugReportQuery + * @param debugReportId uint8_t + */ +#define emberAfFillCommandSlWwahClusterDebugReportQuery(debugReportId) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DEBUG_REPORT_QUERY_COMMAND_ID, \ + "u", \ + debugReportId); + + +/** @brief Causes device to perform a scan for beacons advertising the device's network. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: SurveyBeacons + * @param standardBeacons uint8_t + */ +#define emberAfFillCommandSlWwahClusterSurveyBeacons(standardBeacons) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SURVEY_BEACONS_COMMAND_ID, \ + "u", \ + standardBeacons); + + +/** @brief Disallow OTA downgrade of all device firmware components. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableOtaDowngrades + */ +#define emberAfFillCommandSlWwahClusterDisableOtaDowngrades() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID, \ + ""); + + +/** @brief Causes device to ignore MGMT Leave Without Rejoin commands. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableMgmtLeaveWithoutRejoin + */ +#define emberAfFillCommandSlWwahClusterDisableMgmtLeaveWithoutRejoin() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID, \ + ""); + + +/** @brief Causes device to ignore Touchlink Interpan messages. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableTouchlinkInterpanMessageSupport + */ +#define emberAfFillCommandSlWwahClusterDisableTouchlinkInterpanMessageSupport() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID, \ + ""); + + +/** @brief Enable WWAH Parent Classification advertisements. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableWwahParentClassification + */ +#define emberAfFillCommandSlWwahClusterEnableWwahParentClassification() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, \ + ""); + + +/** @brief Disable WWAH Parent Classification advertisements. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableWwahParentClassification + */ +#define emberAfFillCommandSlWwahClusterDisableWwahParentClassification() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, \ + ""); + + +/** @brief Process only network key rotation commands sent via unicast and encrypted by Trust Center Link Key. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableTcSecurityOnNtwkKeyRotation + */ +#define emberAfFillCommandSlWwahClusterEnableTcSecurityOnNtwkKeyRotation() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID, \ + ""); + + +/** @brief Enable WWAH Bad Parent Recovery feature. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableWwahBadParentRecovery + */ +#define emberAfFillCommandSlWwahClusterEnableWwahBadParentRecovery() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, \ + ""); + + +/** @brief Disable WWAH Bad Parent Recovery feature. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableWwahBadParentRecovery + */ +#define emberAfFillCommandSlWwahClusterDisableWwahBadParentRecovery() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, \ + ""); + + +/** @brief Enable Configuration Mode. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: EnableConfigurationMode + */ +#define emberAfFillCommandSlWwahClusterEnableConfigurationMode() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID, \ + ""); + + +/** @brief Disable Configuration Mode. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DisableConfigurationMode + */ +#define emberAfFillCommandSlWwahClusterDisableConfigurationMode() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID, \ + ""); + + +/** @brief Use only the Trust Center as cluster server for the set of clusters specified. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: UseTrustCenterForClusterServer + * @param numberOfClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServer(numberOfClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID, \ + "ub", \ + numberOfClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Causes device to send an appropriate Trust Center for Cluster Server Query Response command. + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: TrustCenterForClusterServerQuery + */ +#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQuery() \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID, \ + ""); + + +/** @brief Command description for SlAPSLinkKeyAuthorizationQueryResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ApsLinkKeyAuthorizationQueryResponse + * @param clusterId uint16_t + * @param apsLinkKeyAuthStatus uint8_t + */ +#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQueryResponse(clusterId, \ + apsLinkKeyAuthStatus) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID, \ + "vu", \ + clusterId, \ + apsLinkKeyAuthStatus); + + +/** @brief Command description for SlPoweringOffNotification + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: PoweringOffNotification + * @param powerNotificationReason uint8_t + * @param manufacturerId uint16_t + * @param manufacturerReasonLength uint8_t + * @param manufacturerReason uint8_t* + * @param manufacturerReasonLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterPoweringOffNotification(powerNotificationReason, \ + manufacturerId, \ + manufacturerReasonLength, \ + manufacturerReason, \ + manufacturerReasonLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID, \ + "uvub", \ + powerNotificationReason, \ + manufacturerId, \ + manufacturerReasonLength, \ + manufacturerReason, \ + manufacturerReasonLen); + + +/** @brief Command description for SlPoweringOnNotification + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: PoweringOnNotification + * @param powerNotificationReason uint8_t + * @param manufacturerId uint16_t + * @param manufacturerReasonLength uint8_t + * @param manufacturerReason uint8_t* + * @param manufacturerReasonLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterPoweringOnNotification(powerNotificationReason, \ + manufacturerId, \ + manufacturerReasonLength, \ + manufacturerReason, \ + manufacturerReasonLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID, \ + "uvub", \ + powerNotificationReason, \ + manufacturerId, \ + manufacturerReasonLength, \ + manufacturerReason, \ + manufacturerReasonLen); + + +/** @brief Command description for SlShortAddressChange + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ShortAddressChange + * @param deviceEui64 uint8_t* + * @param deviceShort uint16_t + */ +#define emberAfFillCommandSlWwahClusterShortAddressChange(deviceEui64, \ + deviceShort) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID, \ + "8v", \ + deviceEui64, \ + deviceShort); + + +/** @brief Command description for SlAPSAckEnablementQueryResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: ApsAckEnablementQueryResponse + * @param numberExemptClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterApsAckEnablementQueryResponse(numberExemptClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID, \ + "ub", \ + numberExemptClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Command description for SlPowerDescriptorChange + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: PowerDescriptorChange + * @param currentPowerMode uint32_t + * @param availablePowerSources uint32_t + * @param currentPowerSource uint32_t + * @param currentPowerSourceLevel uint32_t + */ +#define emberAfFillCommandSlWwahClusterPowerDescriptorChange(currentPowerMode, \ + availablePowerSources, \ + currentPowerSource, \ + currentPowerSourceLevel) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID, \ + "wwww", \ + currentPowerMode, \ + availablePowerSources, \ + currentPowerSource, \ + currentPowerSourceLevel); + + +/** @brief Command description for SlNewDebugReportNotification + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: NewDebugReportNotification + * @param debugReportId uint8_t + * @param debugReportSize uint32_t + */ +#define emberAfFillCommandSlWwahClusterNewDebugReportNotification(debugReportId, \ + debugReportSize) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID, \ + "uw", \ + debugReportId, \ + debugReportSize); + + +/** @brief Command description for SlDebugReportQueryResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: DebugReportQueryResponse + * @param debugReportId uint8_t + * @param debugReportData uint8_t* + * @param debugReportDataLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterDebugReportQueryResponse(debugReportId, \ + debugReportData, \ + debugReportDataLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID, \ + "ub", \ + debugReportId, \ + debugReportData, \ + debugReportDataLen); + + +/** @brief Command description for SlTrustCenterForClusterServerQueryResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: TrustCenterForClusterServerQueryResponse + * @param numberOfClusters uint8_t + * @param clusterId uint8_t* + * @param clusterIdLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQueryResponse(numberOfClusters, \ + clusterId, \ + clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_RESPONSE_COMMAND_ID, \ + "ub", \ + numberOfClusters, \ + clusterId, \ + clusterIdLen); + + +/** @brief Command description for SlSurveyBeaconsResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: SurveyBeaconsResponse + * @param numberOfBeacons uint8_t + * @param beacon uint8_t* + * @param beaconLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterSurveyBeaconsResponse(numberOfBeacons, \ + beacon, \ + beaconLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID, \ + "ub", \ + numberOfBeacons, \ + beacon, \ + beaconLen); + + +/** @brief Command description for SlUseTrustCenterForClusterServerResponse + * + * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. + * Command: UseTrustCenterForClusterServerResponse + * @param status uint8_t + * @param clusterStatusLength uint8_t + * @param clusterStatus uint8_t* + * @param clusterStatusLen uint16_t + */ +#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServerResponse(status, \ + clusterStatusLength, \ + clusterStatus, \ + clusterStatusLen) \ + emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ + | ZCL_MANUFACTURER_SPECIFIC_MASK \ + | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, \ + 0x1217, \ + ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID, \ + "uub", \ + status, \ + clusterStatusLength, \ + clusterStatus, \ + clusterStatusLen); + + +/** @} END SL Works With All Hubs Commands */ + + + + + +/** @} END addtogroup */ +#endif // SILABS_CLUSTER_CLIENT_API diff --git a/examples/wifi-echo/server/esp32/main/gen/cluster-id.h b/examples/wifi-echo/server/esp32/main/gen/cluster-id.h new file mode 100644 index 00000000000000..40e068f8b32465 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/cluster-id.h @@ -0,0 +1,175 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_CLUSTER_ID +#define SILABS_EMBER_AF_CLUSTER_ID + + +// Cluster domain specification levels: +// * General: zcl-7.0-07-5123-07 +// * Lighting & Occupancy: l&o-1.0-15-0014-04 +// * HA: ha-1.2.1-05-3520-30 +// * Closures: zcl-6.0-15-02018-001 +// * HVAC: zcl-6.0-15-02018-001 +// * Lighting: zcl6-errata-14-0129-15 +// * Measurement & Sensing: zcl-6.0-15-02018-001 +// * Security & Safety: zcl-6.0-15-02018-001 +// * Home Automation: UNKNOWN +// * CBA: cba-1.0-05-3516-12 +// * SE: se-1.2b-15-0131-02 +// * ZLL: zll-1.0-11-0037-10 +// * Telecom Applications: ta-1.0-07-5307-07 +// * Protocol Interfaces: ta-1.0-07-5307-07 +// * Telecommunication: ta-1.0-07-5307-07 +// * Financial: ta-1.0-07-5307-07 +// * Ember: UNKNOWN +// * HC: hc-1.0-07-5360-15 +// * GP: gp-1.0a-09-5499-26 +// * LO: UNKNOWN +// * Works With All Hubs: UNKNOWN +// * WWAH: UNKNOWN +#define ZCL_BASIC_CLUSTER_ID 0x0000 +#define ZCL_POWER_CONFIG_CLUSTER_ID 0x0001 +#define ZCL_DEVICE_TEMP_CLUSTER_ID 0x0002 +#define ZCL_IDENTIFY_CLUSTER_ID 0x0003 +#define ZCL_GROUPS_CLUSTER_ID 0x0004 +#define ZCL_SCENES_CLUSTER_ID 0x0005 +#define ZCL_ON_OFF_CLUSTER_ID 0x0006 +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID 0x0007 +#define ZCL_LEVEL_CONTROL_CLUSTER_ID 0x0008 +#define ZCL_ALARM_CLUSTER_ID 0x0009 +#define ZCL_TIME_CLUSTER_ID 0x000A +#define ZCL_RSSI_LOCATION_CLUSTER_ID 0x000B +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_ID 0x000F +#define ZCL_COMMISSIONING_CLUSTER_ID 0x0015 +#define ZCL_PARTITION_CLUSTER_ID 0x0016 +#define ZCL_OTA_BOOTLOAD_CLUSTER_ID 0x0019 +#define ZCL_POWER_PROFILE_CLUSTER_ID 0x001A +#define ZCL_APPLIANCE_CONTROL_CLUSTER_ID 0x001B +#define ZCL_POLL_CONTROL_CLUSTER_ID 0x0020 +#define ZCL_GREEN_POWER_CLUSTER_ID 0x0021 +#define ZCL_KEEPALIVE_CLUSTER_ID 0x0025 +#define ZCL_SHADE_CONFIG_CLUSTER_ID 0x0100 +#define ZCL_DOOR_LOCK_CLUSTER_ID 0x0101 +#define ZCL_WINDOW_COVERING_CLUSTER_ID 0x0102 +#define ZCL_BARRIER_CONTROL_CLUSTER_ID 0x0103 +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID 0x0200 +#define ZCL_THERMOSTAT_CLUSTER_ID 0x0201 +#define ZCL_FAN_CONTROL_CLUSTER_ID 0x0202 +#define ZCL_DEHUMID_CONTROL_CLUSTER_ID 0x0203 +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID 0x0204 +#define ZCL_COLOR_CONTROL_CLUSTER_ID 0x0300 +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_ID 0x0301 +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_ID 0x0400 +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID 0x0401 +#define ZCL_TEMP_MEASUREMENT_CLUSTER_ID 0x0402 +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID 0x0403 +#define ZCL_FLOW_MEASUREMENT_CLUSTER_ID 0x0404 +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID 0x0405 +#define ZCL_OCCUPANCY_SENSING_CLUSTER_ID 0x0406 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040C +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040D +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040E +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040F +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0410 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0411 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0412 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0413 +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0414 +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0415 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0416 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0417 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0418 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0419 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041A +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041B +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041C +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041D +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041E +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041F +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0420 +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0421 +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0422 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0423 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0424 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0425 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0426 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0427 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0428 +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0429 +#define ZCL_IAS_ZONE_CLUSTER_ID 0x0500 +#define ZCL_IAS_ACE_CLUSTER_ID 0x0501 +#define ZCL_IAS_WD_CLUSTER_ID 0x0502 +#define ZCL_GENERIC_TUNNEL_CLUSTER_ID 0x0600 +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID 0x0601 +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID 0x0614 +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID 0x0615 +#define ZCL_PRICE_CLUSTER_ID 0x0700 +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID 0x0701 +#define ZCL_SIMPLE_METERING_CLUSTER_ID 0x0702 +#define ZCL_MESSAGING_CLUSTER_ID 0x0703 +#define ZCL_TUNNELING_CLUSTER_ID 0x0704 +#define ZCL_PREPAYMENT_CLUSTER_ID 0x0705 +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_ID 0x0706 +#define ZCL_CALENDAR_CLUSTER_ID 0x0707 +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_ID 0x0708 +#define ZCL_EVENTS_CLUSTER_ID 0x0709 +#define ZCL_MDU_PAIRING_CLUSTER_ID 0x070A +#define ZCL_SUB_GHZ_CLUSTER_ID 0x070B +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_ID 0x0800 +#define ZCL_INFORMATION_CLUSTER_ID 0x0900 +#define ZCL_DATA_SHARING_CLUSTER_ID 0x0901 +#define ZCL_GAMING_CLUSTER_ID 0x0902 +#define ZCL_DATA_RATE_CONTROL_CLUSTER_ID 0x0903 +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID 0x0904 +#define ZCL_CHATTING_CLUSTER_ID 0x0905 +#define ZCL_PAYMENT_CLUSTER_ID 0x0A01 +#define ZCL_BILLING_CLUSTER_ID 0x0A02 +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID 0x0B00 +#define ZCL_METER_IDENTIFICATION_CLUSTER_ID 0x0B01 +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID 0x0B02 +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_ID 0x0B03 +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID 0x0B04 +#define ZCL_DIAGNOSTICS_CLUSTER_ID 0x0B05 +#define ZCL_ZLL_COMMISSIONING_CLUSTER_ID 0x1000 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID 0xFC00 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID 0xFC00 +#define ZCL_OTA_CONFIGURATION_CLUSTER_ID 0xFC01 +#define ZCL_MFGLIB_CLUSTER_ID 0xFC02 +#define ZCL_SL_WWAH_CLUSTER_ID 0xFC57 +#endif // SILABS_EMBER_AF_CLUSTER_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/command-id.h b/examples/wifi-echo/server/esp32/main/gen/command-id.h new file mode 100644 index 00000000000000..18812dda04aa23 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/command-id.h @@ -0,0 +1,1095 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_COMMAND_ID +#define SILABS_EMBER_AF_COMMAND_ID + + +// Global commands + +// Either direction +#define ZCL_READ_ATTRIBUTES_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_COMMAND_ID 0x02 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_CONFIGURE_REPORTING_COMMAND_ID 0x06 // Ver.: always +#define ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID 0x08 // Ver.: always +#define ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID 0x09 // Ver.: always +#define ZCL_REPORT_ATTRIBUTES_COMMAND_ID 0x0A // Ver.: always +#define ZCL_DEFAULT_RESPONSE_COMMAND_ID 0x0B // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID 0x0C // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID 0x0D // Ver.: always +#define ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0E // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0F // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID 0x10 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID 0x11 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID 0x12 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID 0x13 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID 0x14 // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID 0x15 // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID 0x16 // Ver.: always +// Command types for cluster: Basic +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_GET_LOCALES_SUPPORTED_RESPONSE_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: Identify +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_IDENTIFY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_IDENTIFY_QUERY_COMMAND_ID 0x01 // Ver.: always +#define ZCL_E_Z_MODE_INVOKE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_TRIGGER_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 + + +// Command types for cluster: Groups +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_ADD_GROUP_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID 0x03 // Ver.: always + +// Client to server +#define ZCL_ADD_GROUP_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_GROUP_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_GROUP_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REMOVE_ALL_GROUPS_COMMAND_ID 0x04 // Ver.: always +#define ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID 0x05 // Ver.: always + + +// Command types for cluster: Scenes +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_ADD_SCENE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_STORE_SCENE_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID 0x06 // Ver.: always +#define ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COPY_SCENE_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 + +// Client to server +#define ZCL_ADD_SCENE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_SCENE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_SCENE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_ALL_SCENES_COMMAND_ID 0x03 // Ver.: always +#define ZCL_STORE_SCENE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_RECALL_SCENE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID 0x06 // Ver.: always +#define ZCL_ENHANCED_ADD_SCENE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COPY_SCENE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 + + +// Command types for cluster: On/off +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client to server +#define ZCL_OFF_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ON_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_OFF_WITH_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_WITH_TIMED_OFF_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1049 +#define ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION2_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1049 + + +// Command types for cluster: Level Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Client to server +#define ZCL_MOVE_TO_LEVEL_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MOVE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_STEP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_STOP_COMMAND_ID 0x03 // Ver.: always +#define ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID 0x04 // Ver.: always +#define ZCL_MOVE_WITH_ON_OFF_COMMAND_ID 0x05 // Ver.: always +#define ZCL_STEP_WITH_ON_OFF_COMMAND_ID 0x06 // Ver.: always +#define ZCL_STOP_WITH_ON_OFF_COMMAND_ID 0x07 // Ver.: always + + +// Command types for cluster: Alarms +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_ALARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_ALARM_RESPONSE_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_RESET_ALARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_RESET_ALL_ALARMS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_ALARM_COMMAND_ID 0x02 // Ver.: always +#define ZCL_RESET_ALARM_LOG_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: RSSI Location +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_COMPACT_LOCATION_DATA_NOTIFICATION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RSSI_PING_COMMAND_ID 0x04 // Ver.: always +#define ZCL_RSSI_REQUEST_COMMAND_ID 0x05 // Ver.: always +#define ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID 0x06 // Ver.: always +#define ZCL_REQUEST_OWN_LOCATION_COMMAND_ID 0x07 // Ver.: always + +// Client to server +#define ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_LOCATION_DATA_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RSSI_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SEND_PINGS_COMMAND_ID 0x05 // Ver.: always +#define ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID 0x06 // Ver.: always + + +// Command types for cluster: Commissioning +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_RESTORE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x03 // Ver.: always + +// Client to server +#define ZCL_RESTART_DEVICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID 0x02 // Ver.: always +#define ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: Partition +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_MULTIPLE_ACK_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_HANDSHAKE_PARAM_RESPONSE_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID 0x02 // Ver.: always + + +// Command types for cluster: Over the Air Bootloading +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_IMAGE_NOTIFY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID 0x09 // Ver.: always + +// Client to server +#define ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID 0x03 // Ver.: always +#define ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID 0x04 // Ver.: always +#define ZCL_UPGRADE_END_REQUEST_COMMAND_ID 0x06 // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID 0x08 // Ver.: always + + +// Command types for cluster: Power Profile +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID 0x06 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID 0x08 // Ver.: always +#define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID 0x09 // Ver.: always +#define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID 0x0B // Ver.: always + +// Client to server +#define ZCL_POWER_PROFILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID 0x06 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID 0x07 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID 0x08 // Ver.: always + + +// Command types for cluster: Appliance Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SIGNAL_STATE_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SIGNAL_STATE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_FUNCTIONS_COMMAND_ID 0x02 // Ver.: always +#define ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID 0x03 // Ver.: always +#define ZCL_OVERLOAD_PAUSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_OVERLOAD_WARNING_COMMAND_ID 0x05 // Ver.: always + + +// Command types for cluster: Poll Control +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_CHECK_IN_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_CHECK_IN_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_FAST_POLL_STOP_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID 0x02 // Ver.: always +#define ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: Green Power +// Cluster specification level: gp-1.0a-09-5499-26 + +// Server to client +#define ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PAIRING_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID 0x02 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_RESPONSE_COMMAND_ID 0x06 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_TRANSLATION_TABLE_RESPONSE_COMMAND_ID 0x08 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID 0x0B // Ver.: always + +// Client to server +#define ZCL_GP_NOTIFICATION_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PAIRING_SEARCH_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_TUNNELING_STOP_COMMAND_ID 0x03 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID 0x04 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID 0x07 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID 0x08 // Ver.: always +#define ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID 0x09 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID 0x0B // Ver.: always + + +// Command types for cluster: Door Lock +// Cluster specification level: zcl-6.0-15-02018-001 + +// Server to client +#define ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_RESPONSE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_PIN_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_PIN_RESPONSE_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x10 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x13 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_RFID_RESPONSE_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_RFID_RESPONSE_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID 0x20 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID 0x21 // Ver.: since ha-1.2-05-3520-29 + +// Client to server +#define ZCL_LOCK_DOOR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNLOCK_DOOR_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_LOG_RECORD_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_PIN_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_PIN_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_PIN_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_PINS_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_STATUS_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID 0x0D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID 0x10 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID 0x13 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_TYPE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_TYPE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_RFID_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_RFID_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_RFID_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_RFIDS_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 + + +// Command types for cluster: Window Covering +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client to server +#define ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID 0x00 // Ver.: always +#define ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WINDOW_COVERING_STOP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID 0x08 // Ver.: always + + +// Command types for cluster: Barrier Control +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client to server +#define ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_BARRIER_CONTROL_STOP_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: Thermostat +// Cluster specification level: zcl-6.0-15-02018-001 + +// Server to client +#define ZCL_CURRENT_WEEKLY_SCHEDULE_COMMAND_ID 0x00 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RELAY_STATUS_LOG_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 + +// Client to server +#define ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 + + +// Command types for cluster: Color Control +// Cluster specification level: zcl6-errata-14-0129-15 + +// Client to server +#define ZCL_MOVE_TO_HUE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MOVE_HUE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_STEP_HUE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_MOVE_TO_SATURATION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_MOVE_SATURATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_STEP_SATURATION_COMMAND_ID 0x05 // Ver.: always +#define ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_MOVE_TO_COLOR_COMMAND_ID 0x07 // Ver.: always +#define ZCL_MOVE_COLOR_COMMAND_ID 0x08 // Ver.: always +#define ZCL_STEP_COLOR_COMMAND_ID 0x09 // Ver.: always +#define ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_MOVE_HUE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_STEP_HUE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID 0x43 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_LOOP_SET_COMMAND_ID 0x44 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_STOP_MOVE_STEP_COMMAND_ID 0x47 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID 0x4B // Ver.: since zll-1.0-11-0037-10 +#define ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID 0x4C // Ver.: since zll-1.0-11-0037-10 + + +// Command types for cluster: IAS Zone +// Cluster specification level: zcl-6.0-15-02018-001 + +// Server to client +#define ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID 0x03 // Ver.: always + +// Client to server +#define ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_INITIATE_TEST_MODE_COMMAND_ID 0x02 // Ver.: always + + +// Command types for cluster: IAS ACE +// Cluster specification level: zcl-6.0-15-02018-001 + +// Server to client +#define ZCL_ARM_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_ZONE_INFORMATION_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_ZONE_STATUS_CHANGED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PANEL_STATUS_CHANGED_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID 0x06 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_BYPASS_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2.1-05-3520-30 + +// Client to server +#define ZCL_ARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_BYPASS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_EMERGENCY_COMMAND_ID 0x02 // Ver.: always +#define ZCL_FIRE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PANIC_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_ZONE_ID_MAP_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_ZONE_INFORMATION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_GET_PANEL_STATUS_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID 0x08 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_GET_ZONE_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2.1-05-3520-30 + + +// Command types for cluster: IAS WD +// Cluster specification level: zcl-6.0-15-02018-001 + +// Client to server +#define ZCL_START_WARNING_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SQUAWK_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: Generic Tunnel +// Cluster specification level: cba-1.0-05-3516-12 + +// Server to client +#define ZCL_MATCH_PROTOCOL_ADDRESS_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: BACnet Protocol Tunnel +// Cluster specification level: cba-1.0-05-3516-12 + +// Client to server +#define ZCL_TRANSFER_NPDU_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: 11073 Protocol Tunnel +// Cluster specification level: hc-1.0-07-5360-15 + +// Client to server +#define ZCL_TRANSFER_A_P_D_U_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CONNECT_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_DISCONNECT_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: ISO 7816 Protocol Tunnel +// Cluster specification level: ta-1.0-07-5307-07 + +// Client to server +#define ZCL_INSERT_SMART_CARD_COMMAND_ID 0x01 // Ver.: always +#define ZCL_EXTRACT_SMART_CARD_COMMAND_ID 0x02 // Ver.: always + +// Either direction +#define ZCL_TRANSFER_APDU_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: Price +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PUBLISH_PRICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID 0x01 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID 0x02 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID 0x03 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_TIER_LABELS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CPP_EVENT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CANCEL_TARIFF_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 + +// Client to server +#define ZCL_GET_CURRENT_PRICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_SCHEDULED_PRICES_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID 0x02 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GET_BLOCK_PERIODS_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GET_CONVERSION_FACTOR_COMMAND_ID 0x04 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_GET_CALORIFIC_VALUE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_GET_TARIFF_INFORMATION_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_PRICE_MATRIX_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_C_O2_VALUE_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_TIER_LABELS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_BILLING_PERIOD_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP_EVENT_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CREDIT_PAYMENT_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID 0x0F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID 0x10 // Ver.: since se-1.2a-07-5356-19 + + +// Command types for cluster: Demand Response and Load Control +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_LOAD_CONTROL_EVENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_REPORT_EVENT_STATUS_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_SCHEDULED_EVENTS_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: Simple Metering +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_GET_PROFILE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_REQUEST_MIRROR_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_MIRROR_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 +#define ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_MIRROR_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_SAMPLING_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 + +// Client to server +#define ZCL_GET_PROFILE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TAKE_SNAPSHOT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_SAMPLING_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SAMPLED_DATA_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CHANGE_SUPPLY_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_SUPPLY_STATUS_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 + + +// Command types for cluster: Messaging +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_DISPLAY_MESSAGE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CANCEL_MESSAGE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 + +// Client to server +#define ZCL_GET_LAST_MESSAGE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MESSAGE_CONFIRMATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_MESSAGE_CANCELLATION_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 + + +// Command types for cluster: Tunneling +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_SERVER_TO_CLIENT_COMMAND_ID 0x02 // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x03 // Ver.: always +#define ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 + +// Client to server +#define ZCL_REQUEST_TUNNEL_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x02 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID 0x03 // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x04 // Ver.: always +#define ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 + + +// Command types for cluster: Prepayment +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID 0x01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CHANGE_PAYMENT_MODE_RESPONSE_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_DEBT_LOG_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 + +// Client to server +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CHANGE_DEBT_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMER_TOP_UP_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_ADJUSTMENT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_TOP_UP_LOG_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 + + +// Command types for cluster: Energy Management +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_REPORT_EVENT_STATUS_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_MANAGE_EVENT_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: Calendar +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PUBLISH_CALENDAR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_PUBLISH_SEASONS_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID 0x04 // Ver.: always +#define ZCL_CANCEL_CALENDAR_COMMAND_ID 0x05 // Ver.: always + +// Client to server +#define ZCL_GET_CALENDAR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_DAY_PROFILES_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_WEEK_PROFILES_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_SEASONS_COMMAND_ID 0x03 // Ver.: always +#define ZCL_GET_SPECIAL_DAYS_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID 0x05 // Ver.: always + + +// Command types for cluster: Device Management +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REQUEST_NEW_PASSWORD_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_UPDATE_SITE_ID_COMMAND_ID 0x03 // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID 0x05 // Ver.: always +#define ZCL_UPDATE_C_I_N_COMMAND_ID 0x06 // Ver.: always + +// Client to server +#define ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_SITE_ID_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_C_I_N_COMMAND_ID 0x05 // Ver.: always + + +// Command types for cluster: Events +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PUBLISH_EVENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_EVENT_LOG_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_GET_EVENT_LOG_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: MDU Pairing +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_PAIRING_RESPONSE_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_PAIRING_REQUEST_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: Sub-GHz +// Cluster specification level: se-1.2b-15-0131-02 + +// Server to client +#define ZCL_SUSPEND_ZCL_MESSAGES_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: Key Establishment +// Cluster specification level: zcl-7.0-07-5123-07 + +// Server to client +#define ZCL_INITIATE_KEY_ESTABLISHMENT_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID 0x02 // Ver.: always + +// Either direction +#define ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: Information +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUSH_INFORMATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REQUEST_PREFERENCE_CONFIRMATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_UPDATE_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_DELETE_RESPONSE_COMMAND_ID 0x06 // Ver.: always + +// Client to server +#define ZCL_REQUEST_INFORMATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEND_PREFERENCE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_UPDATE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_DELETE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID 0x08 // Ver.: always +#define ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID 0x09 // Ver.: always + + +// Command types for cluster: Data Sharing +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_WRITE_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MODIFY_FILE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_MODIFY_RECORD_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_FILE_TRANSMISSION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RECORD_TRANSMISSION_COMMAND_ID 0x04 // Ver.: always + +// Client to server +#define ZCL_READ_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_RECORD_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_FILE_RESPONSE_COMMAND_ID 0x02 // Ver.: always + + +// Command types for cluster: Gaming +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_GAME_ANNOUNCEMENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GENERAL_RESPONSE_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_SEARCH_GAME_COMMAND_ID 0x00 // Ver.: always +#define ZCL_JOIN_GAME_COMMAND_ID 0x01 // Ver.: always +#define ZCL_START_GAME_COMMAND_ID 0x02 // Ver.: always +#define ZCL_PAUSE_GAME_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RESUME_GAME_COMMAND_ID 0x04 // Ver.: always +#define ZCL_QUIT_GAME_COMMAND_ID 0x05 // Ver.: always +#define ZCL_END_GAME_COMMAND_ID 0x06 // Ver.: always +#define ZCL_START_OVER_COMMAND_ID 0x07 // Ver.: always +#define ZCL_ACTION_CONTROL_COMMAND_ID 0x08 // Ver.: always +#define ZCL_DOWNLOAD_GAME_COMMAND_ID 0x09 // Ver.: always + + +// Command types for cluster: Data Rate Control +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_DATA_RATE_CONTROL_COMMAND_ID 0x00 // Ver.: always + +// Client to server +#define ZCL_PATH_CREATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PATH_DELETION_COMMAND_ID 0x02 // Ver.: always + + +// Command types for cluster: Voice over ZigBee +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VOICE_TRANSMISSION_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CONTROL_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VOICE_TRANSMISSION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_CONTROL_RESPONSE_COMMAND_ID 0x03 // Ver.: always + + +// Command types for cluster: Chatting +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_START_CHAT_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_USER_LEFT_COMMAND_ID 0x02 // Ver.: always +#define ZCL_USER_JOINED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID 0x05 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID 0x06 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID 0x07 // Ver.: always +#define ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID 0x08 // Ver.: always + +// Client to server +#define ZCL_JOIN_CHAT_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_START_CHAT_REQUEST_COMMAND_ID 0x04 // Ver.: always +#define ZCL_CHAT_MESSAGE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID 0x06 // Ver.: always + + +// Command types for cluster: Payment +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_BUY_CONFIRM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_RECEIPT_DELIVERY_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TRANSACTION_END_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_BUY_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ACCEPT_PAYMENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PAYMENT_CONFIRM_COMMAND_ID 0x02 // Ver.: always + + +// Command types for cluster: Billing +// Cluster specification level: ta-1.0-07-5307-07 + +// Server to client +#define ZCL_CHECK_BILL_STATUS_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SEND_BILL_RECORD_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_SUBSCRIBE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNSUBSCRIBE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_START_BILLING_SESSION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_STOP_BILLING_SESSION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SESSION_KEEP_ALIVE_COMMAND_ID 0x05 // Ver.: always + + +// Command types for cluster: Appliance Events and Alert +// Cluster specification level: UNKNOWN + +// Server to client +#define ZCL_GET_ALERTS_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ALERTS_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_EVENTS_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always + +// Client to server +#define ZCL_GET_ALERTS_COMMAND_ID 0x00 // Ver.: always + + +// Command types for cluster: Appliance Statistics +// Cluster specification level: UNKNOWN + +// Server to client +#define ZCL_LOG_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOG_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_STATISTICS_AVAILABLE_COMMAND_ID 0x03 // Ver.: always + +// Client to server +#define ZCL_LOG_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOG_QUEUE_REQUEST_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: Electrical Measurement +// Cluster specification level: UNKNOWN + +// Server to client +#define ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID 0x01 // Ver.: always + +// Client to server +#define ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_MEASUREMENT_PROFILE_COMMAND_COMMAND_ID 0x01 // Ver.: always + + +// Command types for cluster: ZLL Commissioning +// Cluster specification level: zll-1.0-11-0037-10 + +// Server to client +#define ZCL_SCAN_RESPONSE_COMMAND_ID 0x01 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID 0x03 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_START_RESPONSE_COMMAND_ID 0x11 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID 0x13 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID 0x15 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENDPOINT_INFORMATION_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 + +// Client to server +#define ZCL_SCAN_REQUEST_COMMAND_ID 0x00 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID 0x02 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_IDENTIFY_REQUEST_COMMAND_ID 0x06 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID 0x07 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_START_REQUEST_COMMAND_ID 0x10 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID 0x12 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID 0x14 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID 0x16 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 + + +// Command types for cluster: Sample Mfg Specific Cluster +// Cluster specification level: UNKNOWN + +// Client to server +#define ZCL_COMMAND_ONE_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 + + +// Command types for cluster: Sample Mfg Specific Cluster 2 +// Cluster specification level: UNKNOWN + +// Client to server +#define ZCL_COMMAND_TWO_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1049 + + +// Command types for cluster: Configuration Cluster +// Cluster specification level: UNKNOWN + +// Server to client +#define ZCL_RETURN_TOKEN_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 + +// Client to server +#define ZCL_SET_TOKEN_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_LOCK_TOKENS_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_READ_TOKENS_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 +#define ZCL_UNLOCK_TOKENS_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1002 + + +// Command types for cluster: MFGLIB Cluster +// Cluster specification level: UNKNOWN + +// Client to server +#define ZCL_STREAM_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_TONE_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_RX_MODE_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 + + +// Command types for cluster: SL Works With All Hubs +// Cluster specification level: UNKNOWN + +// Server to client +#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 +#define ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 +#define ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 +#define ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 +#define ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_RESPONSE_COMMAND_ID 0x08 // Ver.: always mfgCode: 0x1217 +#define ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 +#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID 0x9E // Ver.: always mfgCode: 0x1217 + +// Client to server +#define ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUEST_TIME_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x08 // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 +#define ZCL_CLEAR_BINDING_TABLE_COMMAND_ID 0x0A // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0B // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0C // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID 0x0D // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID 0x0E // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID 0x0F // Ver.: always mfgCode: 0x1217 +#define ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID 0x10 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID 0x11 // Ver.: always mfgCode: 0x1217 +#define ZCL_DEBUG_REPORT_QUERY_COMMAND_ID 0x12 // Ver.: always mfgCode: 0x1217 +#define ZCL_SURVEY_BEACONS_COMMAND_ID 0x13 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID 0x14 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID 0x15 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID 0x16 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x17 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x18 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID 0x19 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1A // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1B // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID 0x1C // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID 0x1D // Ver.: always mfgCode: 0x1217 +#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID 0x1E // Ver.: always mfgCode: 0x1217 +#define ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID 0x1F // Ver.: always mfgCode: 0x1217 + + +#endif // SILABS_EMBER_AF_COMMAND_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/debug-printing.h b/examples/wifi-echo/server/esp32/main/gen/debug-printing.h new file mode 100644 index 00000000000000..4cf70a6a7b1760 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/debug-printing.h @@ -0,0 +1,2354 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_DEBUG_PRINTING +#define SILABS_EMBER_AF_DEBUG_PRINTING + + +// Printing macros for cluster: Basic +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER) +#define emberAfBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__) +#define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBasicClusterFlush() +#define emberAfBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER) ) { x; } +#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer)) +#else +#define emberAfBasicClusterPrint(...) +#define emberAfBasicClusterPrintln(...) +#define emberAfBasicClusterFlush() +#define emberAfBasicClusterDebugExec(x) +#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBasicClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER) + + +// Printing macros for cluster: Power Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) +#define emberAfPowerConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPowerConfigClusterFlush() +#define emberAfPowerConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) ) { x; } +#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPowerConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer)) +#else +#define emberAfPowerConfigClusterPrint(...) +#define emberAfPowerConfigClusterPrintln(...) +#define emberAfPowerConfigClusterFlush() +#define emberAfPowerConfigClusterDebugExec(x) +#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPowerConfigClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) + + +// Printing macros for cluster: Device Temperature Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) +#define emberAfDeviceTempClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__) +#define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDeviceTempClusterFlush() +#define emberAfDeviceTempClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) ) { x; } +#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDeviceTempClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer)) +#else +#define emberAfDeviceTempClusterPrint(...) +#define emberAfDeviceTempClusterPrintln(...) +#define emberAfDeviceTempClusterFlush() +#define emberAfDeviceTempClusterDebugExec(x) +#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDeviceTempClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) + + +// Printing macros for cluster: Identify +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER) +#define emberAfIdentifyClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__) +#define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIdentifyClusterFlush() +#define emberAfIdentifyClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER) ) { x; } +#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIdentifyClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer)) +#else +#define emberAfIdentifyClusterPrint(...) +#define emberAfIdentifyClusterPrintln(...) +#define emberAfIdentifyClusterFlush() +#define emberAfIdentifyClusterDebugExec(x) +#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIdentifyClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER) + + +// Printing macros for cluster: Groups +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER) +#define emberAfGroupsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__) +#define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfGroupsClusterFlush() +#define emberAfGroupsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER) ) { x; } +#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGroupsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer)) +#else +#define emberAfGroupsClusterPrint(...) +#define emberAfGroupsClusterPrintln(...) +#define emberAfGroupsClusterFlush() +#define emberAfGroupsClusterDebugExec(x) +#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) +#define emberAfGroupsClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER) + + +// Printing macros for cluster: Scenes +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER) +#define emberAfScenesClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__) +#define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfScenesClusterFlush() +#define emberAfScenesClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER) ) { x; } +#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfScenesClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer)) +#else +#define emberAfScenesClusterPrint(...) +#define emberAfScenesClusterPrintln(...) +#define emberAfScenesClusterFlush() +#define emberAfScenesClusterDebugExec(x) +#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) +#define emberAfScenesClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER) + + +// Printing macros for cluster: On/off +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER) +#define emberAfOnOffClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__) +#define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOnOffClusterFlush() +#define emberAfOnOffClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER) ) { x; } +#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOnOffClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer)) +#else +#define emberAfOnOffClusterPrint(...) +#define emberAfOnOffClusterPrintln(...) +#define emberAfOnOffClusterFlush() +#define emberAfOnOffClusterDebugExec(x) +#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOnOffClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER) + + +// Printing macros for cluster: On/off Switch Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) +#define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOnOffSwitchConfigClusterFlush() +#define emberAfOnOffSwitchConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) ) { x; } +#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOnOffSwitchConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer)) +#else +#define emberAfOnOffSwitchConfigClusterPrint(...) +#define emberAfOnOffSwitchConfigClusterPrintln(...) +#define emberAfOnOffSwitchConfigClusterFlush() +#define emberAfOnOffSwitchConfigClusterDebugExec(x) +#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOnOffSwitchConfigClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) + + +// Printing macros for cluster: Level Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) +#define emberAfLevelControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfLevelControlClusterFlush() +#define emberAfLevelControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) ) { x; } +#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfLevelControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfLevelControlClusterPrint(...) +#define emberAfLevelControlClusterPrintln(...) +#define emberAfLevelControlClusterFlush() +#define emberAfLevelControlClusterDebugExec(x) +#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfLevelControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) + + +// Printing macros for cluster: Alarms +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER) +#define emberAfAlarmClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__) +#define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfAlarmClusterFlush() +#define emberAfAlarmClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER) ) { x; } +#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfAlarmClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer)) +#else +#define emberAfAlarmClusterPrint(...) +#define emberAfAlarmClusterPrintln(...) +#define emberAfAlarmClusterFlush() +#define emberAfAlarmClusterDebugExec(x) +#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) +#define emberAfAlarmClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER) + + +// Printing macros for cluster: Time +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER) +#define emberAfTimeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__) +#define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTimeClusterFlush() +#define emberAfTimeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER) ) { x; } +#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTimeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TIME_CLUSTER, (buffer)) +#else +#define emberAfTimeClusterPrint(...) +#define emberAfTimeClusterPrintln(...) +#define emberAfTimeClusterFlush() +#define emberAfTimeClusterDebugExec(x) +#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTimeClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER) + + +// Printing macros for cluster: RSSI Location +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) +#define emberAfRssiLocationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__) +#define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfRssiLocationClusterFlush() +#define emberAfRssiLocationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) ) { x; } +#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfRssiLocationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer)) +#else +#define emberAfRssiLocationClusterPrint(...) +#define emberAfRssiLocationClusterPrintln(...) +#define emberAfRssiLocationClusterFlush() +#define emberAfRssiLocationClusterDebugExec(x) +#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfRssiLocationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) + + +// Printing macros for cluster: Binary Input (Basic) +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) +#define emberAfBinaryInputBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__) +#define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBinaryInputBasicClusterFlush() +#define emberAfBinaryInputBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) ) { x; } +#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBinaryInputBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer)) +#else +#define emberAfBinaryInputBasicClusterPrint(...) +#define emberAfBinaryInputBasicClusterPrintln(...) +#define emberAfBinaryInputBasicClusterFlush() +#define emberAfBinaryInputBasicClusterDebugExec(x) +#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBinaryInputBasicClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) + + +// Printing macros for cluster: Commissioning +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) +#define emberAfCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__) +#define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCommissioningClusterFlush() +#define emberAfCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) ) { x; } +#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer)) +#else +#define emberAfCommissioningClusterPrint(...) +#define emberAfCommissioningClusterPrintln(...) +#define emberAfCommissioningClusterFlush() +#define emberAfCommissioningClusterDebugExec(x) +#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) +#define emberAfCommissioningClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) + + +// Printing macros for cluster: Partition +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER) +#define emberAfPartitionClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__) +#define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPartitionClusterFlush() +#define emberAfPartitionClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER) ) { x; } +#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPartitionClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer)) +#else +#define emberAfPartitionClusterPrint(...) +#define emberAfPartitionClusterPrintln(...) +#define emberAfPartitionClusterFlush() +#define emberAfPartitionClusterDebugExec(x) +#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPartitionClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER) + + +// Printing macros for cluster: Over the Air Bootloading +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) +#define emberAfOtaBootloadClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__) +#define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOtaBootloadClusterFlush() +#define emberAfOtaBootloadClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) ) { x; } +#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOtaBootloadClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer)) +#else +#define emberAfOtaBootloadClusterPrint(...) +#define emberAfOtaBootloadClusterPrintln(...) +#define emberAfOtaBootloadClusterFlush() +#define emberAfOtaBootloadClusterDebugExec(x) +#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOtaBootloadClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) + + +// Printing macros for cluster: Power Profile +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) +#define emberAfPowerProfileClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__) +#define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPowerProfileClusterFlush() +#define emberAfPowerProfileClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) ) { x; } +#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPowerProfileClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer)) +#else +#define emberAfPowerProfileClusterPrint(...) +#define emberAfPowerProfileClusterPrintln(...) +#define emberAfPowerProfileClusterFlush() +#define emberAfPowerProfileClusterDebugExec(x) +#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPowerProfileClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) + + +// Printing macros for cluster: Appliance Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) +#define emberAfApplianceControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfApplianceControlClusterFlush() +#define emberAfApplianceControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) ) { x; } +#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfApplianceControlClusterPrint(...) +#define emberAfApplianceControlClusterPrintln(...) +#define emberAfApplianceControlClusterFlush() +#define emberAfApplianceControlClusterDebugExec(x) +#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfApplianceControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) + + +// Printing macros for cluster: Poll Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) +#define emberAfPollControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPollControlClusterFlush() +#define emberAfPollControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) ) { x; } +#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPollControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfPollControlClusterPrint(...) +#define emberAfPollControlClusterPrintln(...) +#define emberAfPollControlClusterFlush() +#define emberAfPollControlClusterDebugExec(x) +#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPollControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) + + +// Printing macros for cluster: Green Power +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) +#define emberAfGreenPowerClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__) +#define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfGreenPowerClusterFlush() +#define emberAfGreenPowerClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) ) { x; } +#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGreenPowerClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer)) +#else +#define emberAfGreenPowerClusterPrint(...) +#define emberAfGreenPowerClusterPrintln(...) +#define emberAfGreenPowerClusterFlush() +#define emberAfGreenPowerClusterDebugExec(x) +#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) +#define emberAfGreenPowerClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) + + +// Printing macros for cluster: Keep-Alive +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) +#define emberAfKeepaliveClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__) +#define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfKeepaliveClusterFlush() +#define emberAfKeepaliveClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) ) { x; } +#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfKeepaliveClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer)) +#else +#define emberAfKeepaliveClusterPrint(...) +#define emberAfKeepaliveClusterPrintln(...) +#define emberAfKeepaliveClusterFlush() +#define emberAfKeepaliveClusterDebugExec(x) +#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) +#define emberAfKeepaliveClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) + + +// Printing macros for cluster: Shade Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) +#define emberAfShadeConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfShadeConfigClusterFlush() +#define emberAfShadeConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) ) { x; } +#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfShadeConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer)) +#else +#define emberAfShadeConfigClusterPrint(...) +#define emberAfShadeConfigClusterPrintln(...) +#define emberAfShadeConfigClusterFlush() +#define emberAfShadeConfigClusterDebugExec(x) +#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) +#define emberAfShadeConfigClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) + + +// Printing macros for cluster: Door Lock +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) +#define emberAfDoorLockClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__) +#define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDoorLockClusterFlush() +#define emberAfDoorLockClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) ) { x; } +#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDoorLockClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer)) +#else +#define emberAfDoorLockClusterPrint(...) +#define emberAfDoorLockClusterPrintln(...) +#define emberAfDoorLockClusterFlush() +#define emberAfDoorLockClusterDebugExec(x) +#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDoorLockClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) + + +// Printing macros for cluster: Window Covering +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) +#define emberAfWindowCoveringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__) +#define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfWindowCoveringClusterFlush() +#define emberAfWindowCoveringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) ) { x; } +#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfWindowCoveringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer)) +#else +#define emberAfWindowCoveringClusterPrint(...) +#define emberAfWindowCoveringClusterPrintln(...) +#define emberAfWindowCoveringClusterFlush() +#define emberAfWindowCoveringClusterDebugExec(x) +#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) +#define emberAfWindowCoveringClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) + + +// Printing macros for cluster: Barrier Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) +#define emberAfBarrierControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBarrierControlClusterFlush() +#define emberAfBarrierControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) ) { x; } +#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBarrierControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfBarrierControlClusterPrint(...) +#define emberAfBarrierControlClusterPrintln(...) +#define emberAfBarrierControlClusterFlush() +#define emberAfBarrierControlClusterDebugExec(x) +#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBarrierControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) + + +// Printing macros for cluster: Pump Configuration and Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) +#define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPumpConfigControlClusterFlush() +#define emberAfPumpConfigControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) ) { x; } +#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPumpConfigControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfPumpConfigControlClusterPrint(...) +#define emberAfPumpConfigControlClusterPrintln(...) +#define emberAfPumpConfigControlClusterFlush() +#define emberAfPumpConfigControlClusterDebugExec(x) +#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPumpConfigControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) + + +// Printing macros for cluster: Thermostat +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) +#define emberAfThermostatClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__) +#define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfThermostatClusterFlush() +#define emberAfThermostatClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) ) { x; } +#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfThermostatClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer)) +#else +#define emberAfThermostatClusterPrint(...) +#define emberAfThermostatClusterPrintln(...) +#define emberAfThermostatClusterFlush() +#define emberAfThermostatClusterDebugExec(x) +#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) +#define emberAfThermostatClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) + + +// Printing macros for cluster: Fan Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) +#define emberAfFanControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfFanControlClusterFlush() +#define emberAfFanControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) ) { x; } +#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFanControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfFanControlClusterPrint(...) +#define emberAfFanControlClusterPrintln(...) +#define emberAfFanControlClusterFlush() +#define emberAfFanControlClusterDebugExec(x) +#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfFanControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) + + +// Printing macros for cluster: Dehumidification Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) +#define emberAfDehumidControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDehumidControlClusterFlush() +#define emberAfDehumidControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) ) { x; } +#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDehumidControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfDehumidControlClusterPrint(...) +#define emberAfDehumidControlClusterPrintln(...) +#define emberAfDehumidControlClusterFlush() +#define emberAfDehumidControlClusterDebugExec(x) +#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDehumidControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) + + +// Printing macros for cluster: Thermostat User Interface Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) +#define emberAfThermostatUiConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfThermostatUiConfigClusterFlush() +#define emberAfThermostatUiConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) ) { x; } +#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfThermostatUiConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer)) +#else +#define emberAfThermostatUiConfigClusterPrint(...) +#define emberAfThermostatUiConfigClusterPrintln(...) +#define emberAfThermostatUiConfigClusterFlush() +#define emberAfThermostatUiConfigClusterDebugExec(x) +#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) +#define emberAfThermostatUiConfigClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) + + +// Printing macros for cluster: Color Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) +#define emberAfColorControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfColorControlClusterFlush() +#define emberAfColorControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) ) { x; } +#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfColorControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfColorControlClusterPrint(...) +#define emberAfColorControlClusterPrintln(...) +#define emberAfColorControlClusterFlush() +#define emberAfColorControlClusterDebugExec(x) +#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfColorControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) + + +// Printing macros for cluster: Ballast Configuration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) +#define emberAfBallastConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__) +#define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBallastConfigurationClusterFlush() +#define emberAfBallastConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) ) { x; } +#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBallastConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer)) +#else +#define emberAfBallastConfigurationClusterPrint(...) +#define emberAfBallastConfigurationClusterPrintln(...) +#define emberAfBallastConfigurationClusterFlush() +#define emberAfBallastConfigurationClusterDebugExec(x) +#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBallastConfigurationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) + + +// Printing macros for cluster: Illuminance Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) +#define emberAfIllumMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIllumMeasurementClusterFlush() +#define emberAfIllumMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIllumMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfIllumMeasurementClusterPrint(...) +#define emberAfIllumMeasurementClusterPrintln(...) +#define emberAfIllumMeasurementClusterFlush() +#define emberAfIllumMeasurementClusterDebugExec(x) +#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIllumMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Illuminance Level Sensing +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) +#define emberAfIllumLevelSensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__) +#define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIllumLevelSensingClusterFlush() +#define emberAfIllumLevelSensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) ) { x; } +#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIllumLevelSensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer)) +#else +#define emberAfIllumLevelSensingClusterPrint(...) +#define emberAfIllumLevelSensingClusterPrintln(...) +#define emberAfIllumLevelSensingClusterFlush() +#define emberAfIllumLevelSensingClusterDebugExec(x) +#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIllumLevelSensingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) + + +// Printing macros for cluster: Temperature Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) +#define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTempMeasurementClusterFlush() +#define emberAfTempMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTempMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfTempMeasurementClusterPrint(...) +#define emberAfTempMeasurementClusterPrintln(...) +#define emberAfTempMeasurementClusterFlush() +#define emberAfTempMeasurementClusterDebugExec(x) +#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTempMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Pressure Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) +#define emberAfPressureMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPressureMeasurementClusterFlush() +#define emberAfPressureMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPressureMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfPressureMeasurementClusterPrint(...) +#define emberAfPressureMeasurementClusterPrintln(...) +#define emberAfPressureMeasurementClusterFlush() +#define emberAfPressureMeasurementClusterDebugExec(x) +#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPressureMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Flow Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) +#define emberAfFlowMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfFlowMeasurementClusterFlush() +#define emberAfFlowMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFlowMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfFlowMeasurementClusterPrint(...) +#define emberAfFlowMeasurementClusterPrintln(...) +#define emberAfFlowMeasurementClusterFlush() +#define emberAfFlowMeasurementClusterDebugExec(x) +#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfFlowMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Relative Humidity Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) +#define emberAfRelativeHumidityMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfRelativeHumidityMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfRelativeHumidityMeasurementClusterFlush() +#define emberAfRelativeHumidityMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfRelativeHumidityMeasurementClusterPrint(...) +#define emberAfRelativeHumidityMeasurementClusterPrintln(...) +#define emberAfRelativeHumidityMeasurementClusterFlush() +#define emberAfRelativeHumidityMeasurementClusterDebugExec(x) +#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Occupancy Sensing +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) +#define emberAfOccupancySensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__) +#define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOccupancySensingClusterFlush() +#define emberAfOccupancySensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) ) { x; } +#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOccupancySensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer)) +#else +#define emberAfOccupancySensingClusterPrint(...) +#define emberAfOccupancySensingClusterPrintln(...) +#define emberAfOccupancySensingClusterFlush() +#define emberAfOccupancySensingClusterDebugExec(x) +#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOccupancySensingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) + + +// Printing macros for cluster: Carbon Monoxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush() +#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush() +#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Carbon Dioxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCarbonDioxideConcentrationMeasurementClusterFlush() +#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) +#define emberAfCarbonDioxideConcentrationMeasurementClusterFlush() +#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Ethylene Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfEthyleneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfEthyleneConcentrationMeasurementClusterFlush() +#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfEthyleneConcentrationMeasurementClusterPrint(...) +#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) +#define emberAfEthyleneConcentrationMeasurementClusterFlush() +#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) +#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Ethylene Oxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfEthyleneOxideConcentrationMeasurementClusterFlush() +#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) +#define emberAfEthyleneOxideConcentrationMeasurementClusterFlush() +#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Hydrogen Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfHydrogenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfHydrogenConcentrationMeasurementClusterFlush() +#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfHydrogenConcentrationMeasurementClusterPrint(...) +#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) +#define emberAfHydrogenConcentrationMeasurementClusterFlush() +#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) +#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Hydrogen Sulphide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush() +#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush() +#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Nitric Oxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfNitricOxideConcentrationMeasurementClusterFlush() +#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) +#define emberAfNitricOxideConcentrationMeasurementClusterFlush() +#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Nitrogen Dioxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush() +#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush() +#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Oxygen Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOxygenConcentrationMeasurementClusterFlush() +#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfOxygenConcentrationMeasurementClusterPrint(...) +#define emberAfOxygenConcentrationMeasurementClusterPrintln(...) +#define emberAfOxygenConcentrationMeasurementClusterFlush() +#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) +#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Ozone Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfOzoneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOzoneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOzoneConcentrationMeasurementClusterFlush() +#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfOzoneConcentrationMeasurementClusterPrint(...) +#define emberAfOzoneConcentrationMeasurementClusterPrintln(...) +#define emberAfOzoneConcentrationMeasurementClusterFlush() +#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) +#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Sulfur Dioxide Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSulfurDioxideConcentrationMeasurementClusterFlush() +#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) +#define emberAfSulfurDioxideConcentrationMeasurementClusterFlush() +#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Dissolved Oxygen Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush() +#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush() +#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Bromate Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfBromateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBromateConcentrationMeasurementClusterFlush() +#define emberAfBromateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfBromateConcentrationMeasurementClusterPrint(...) +#define emberAfBromateConcentrationMeasurementClusterPrintln(...) +#define emberAfBromateConcentrationMeasurementClusterFlush() +#define emberAfBromateConcentrationMeasurementClusterDebugExec(x) +#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Chloramines Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfChloraminesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfChloraminesConcentrationMeasurementClusterFlush() +#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfChloraminesConcentrationMeasurementClusterPrint(...) +#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) +#define emberAfChloraminesConcentrationMeasurementClusterFlush() +#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) +#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Chlorine Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfChlorineConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorineConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfChlorineConcentrationMeasurementClusterFlush() +#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfChlorineConcentrationMeasurementClusterPrint(...) +#define emberAfChlorineConcentrationMeasurementClusterPrintln(...) +#define emberAfChlorineConcentrationMeasurementClusterFlush() +#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) +#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Fecal coliform and E. Coli Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush() +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush() +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Fluoride Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfFluorideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFluorideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfFluorideConcentrationMeasurementClusterFlush() +#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfFluorideConcentrationMeasurementClusterPrint(...) +#define emberAfFluorideConcentrationMeasurementClusterPrintln(...) +#define emberAfFluorideConcentrationMeasurementClusterFlush() +#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) +#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Haloacetic Acids Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush() +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush() +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Total Trihalomethanes Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush() +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush() +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Total Coliform Bacteria Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush() +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush() +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Turbidity Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfTurbidityConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTurbidityConcentrationMeasurementClusterFlush() +#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfTurbidityConcentrationMeasurementClusterPrint(...) +#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) +#define emberAfTurbidityConcentrationMeasurementClusterFlush() +#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) +#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Copper Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfCopperConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCopperConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCopperConcentrationMeasurementClusterFlush() +#define emberAfCopperConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfCopperConcentrationMeasurementClusterPrint(...) +#define emberAfCopperConcentrationMeasurementClusterPrintln(...) +#define emberAfCopperConcentrationMeasurementClusterFlush() +#define emberAfCopperConcentrationMeasurementClusterDebugExec(x) +#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Lead Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfLeadConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfLeadConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfLeadConcentrationMeasurementClusterFlush() +#define emberAfLeadConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfLeadConcentrationMeasurementClusterPrint(...) +#define emberAfLeadConcentrationMeasurementClusterPrintln(...) +#define emberAfLeadConcentrationMeasurementClusterFlush() +#define emberAfLeadConcentrationMeasurementClusterDebugExec(x) +#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Manganese Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfManganeseConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfManganeseConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfManganeseConcentrationMeasurementClusterFlush() +#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfManganeseConcentrationMeasurementClusterPrint(...) +#define emberAfManganeseConcentrationMeasurementClusterPrintln(...) +#define emberAfManganeseConcentrationMeasurementClusterFlush() +#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) +#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Sulfate Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfSulfateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSulfateConcentrationMeasurementClusterFlush() +#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfSulfateConcentrationMeasurementClusterPrint(...) +#define emberAfSulfateConcentrationMeasurementClusterPrintln(...) +#define emberAfSulfateConcentrationMeasurementClusterFlush() +#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) +#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Bromodichloromethane Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush() +#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush() +#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Bromoform Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfBromoformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromoformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBromoformConcentrationMeasurementClusterFlush() +#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfBromoformConcentrationMeasurementClusterPrint(...) +#define emberAfBromoformConcentrationMeasurementClusterPrintln(...) +#define emberAfBromoformConcentrationMeasurementClusterFlush() +#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) +#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Chlorodibromomethane Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush() +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush() +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Chloroform Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfChloroformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloroformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfChloroformConcentrationMeasurementClusterFlush() +#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfChloroformConcentrationMeasurementClusterPrint(...) +#define emberAfChloroformConcentrationMeasurementClusterPrintln(...) +#define emberAfChloroformConcentrationMeasurementClusterFlush() +#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) +#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Sodium Concentration Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) +#define emberAfSodiumConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSodiumConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSodiumConcentrationMeasurementClusterFlush() +#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfSodiumConcentrationMeasurementClusterPrint(...) +#define emberAfSodiumConcentrationMeasurementClusterPrintln(...) +#define emberAfSodiumConcentrationMeasurementClusterFlush() +#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) +#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: IAS Zone +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) +#define emberAfIasZoneClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__) +#define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIasZoneClusterFlush() +#define emberAfIasZoneClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) ) { x; } +#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasZoneClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer)) +#else +#define emberAfIasZoneClusterPrint(...) +#define emberAfIasZoneClusterPrintln(...) +#define emberAfIasZoneClusterFlush() +#define emberAfIasZoneClusterDebugExec(x) +#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIasZoneClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) + + +// Printing macros for cluster: IAS ACE +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER) +#define emberAfIasAceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__) +#define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIasAceClusterFlush() +#define emberAfIasAceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER) ) { x; } +#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasAceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer)) +#else +#define emberAfIasAceClusterPrint(...) +#define emberAfIasAceClusterPrintln(...) +#define emberAfIasAceClusterFlush() +#define emberAfIasAceClusterDebugExec(x) +#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIasAceClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER) + + +// Printing macros for cluster: IAS WD +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER) +#define emberAfIasWdClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__) +#define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIasWdClusterFlush() +#define emberAfIasWdClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER) ) { x; } +#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasWdClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer)) +#else +#define emberAfIasWdClusterPrint(...) +#define emberAfIasWdClusterPrintln(...) +#define emberAfIasWdClusterFlush() +#define emberAfIasWdClusterDebugExec(x) +#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIasWdClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER) + + +// Printing macros for cluster: Generic Tunnel +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) +#define emberAfGenericTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfGenericTunnelClusterFlush() +#define emberAfGenericTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) ) { x; } +#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGenericTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer)) +#else +#define emberAfGenericTunnelClusterPrint(...) +#define emberAfGenericTunnelClusterPrintln(...) +#define emberAfGenericTunnelClusterFlush() +#define emberAfGenericTunnelClusterDebugExec(x) +#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) +#define emberAfGenericTunnelClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) + + +// Printing macros for cluster: BACnet Protocol Tunnel +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) +#define emberAfBacnetProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBacnetProtocolTunnelClusterFlush() +#define emberAfBacnetProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) ) { x; } +#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBacnetProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#else +#define emberAfBacnetProtocolTunnelClusterPrint(...) +#define emberAfBacnetProtocolTunnelClusterPrintln(...) +#define emberAfBacnetProtocolTunnelClusterFlush() +#define emberAfBacnetProtocolTunnelClusterDebugExec(x) +#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBacnetProtocolTunnelClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) + + +// Printing macros for cluster: 11073 Protocol Tunnel +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) +#define emberAf11073ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAf11073ProtocolTunnelClusterFlush() +#define emberAf11073ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) ) { x; } +#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAf11073ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#else +#define emberAf11073ProtocolTunnelClusterPrint(...) +#define emberAf11073ProtocolTunnelClusterPrintln(...) +#define emberAf11073ProtocolTunnelClusterFlush() +#define emberAf11073ProtocolTunnelClusterDebugExec(x) +#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) +#define emberAf11073ProtocolTunnelClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) + + +// Printing macros for cluster: ISO 7816 Protocol Tunnel +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) +#define emberAfIso7816ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfIso7816ProtocolTunnelClusterFlush() +#define emberAfIso7816ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) ) { x; } +#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#else +#define emberAfIso7816ProtocolTunnelClusterPrint(...) +#define emberAfIso7816ProtocolTunnelClusterPrintln(...) +#define emberAfIso7816ProtocolTunnelClusterFlush() +#define emberAfIso7816ProtocolTunnelClusterDebugExec(x) +#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) +#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) + + +// Printing macros for cluster: Price +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER) +#define emberAfPriceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__) +#define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPriceClusterFlush() +#define emberAfPriceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER) ) { x; } +#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPriceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer)) +#else +#define emberAfPriceClusterPrint(...) +#define emberAfPriceClusterPrintln(...) +#define emberAfPriceClusterFlush() +#define emberAfPriceClusterDebugExec(x) +#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPriceClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER) + + +// Printing macros for cluster: Demand Response and Load Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) +#define emberAfDemandResponseLoadControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDemandResponseLoadControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDemandResponseLoadControlClusterFlush() +#define emberAfDemandResponseLoadControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) ) { x; } +#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDemandResponseLoadControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfDemandResponseLoadControlClusterPrint(...) +#define emberAfDemandResponseLoadControlClusterPrintln(...) +#define emberAfDemandResponseLoadControlClusterFlush() +#define emberAfDemandResponseLoadControlClusterDebugExec(x) +#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDemandResponseLoadControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) + + +// Printing macros for cluster: Simple Metering +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) +#define emberAfSimpleMeteringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__) +#define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSimpleMeteringClusterFlush() +#define emberAfSimpleMeteringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) ) { x; } +#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSimpleMeteringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer)) +#else +#define emberAfSimpleMeteringClusterPrint(...) +#define emberAfSimpleMeteringClusterPrintln(...) +#define emberAfSimpleMeteringClusterFlush() +#define emberAfSimpleMeteringClusterDebugExec(x) +#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSimpleMeteringClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) + + +// Printing macros for cluster: Messaging +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER) +#define emberAfMessagingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__) +#define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfMessagingClusterFlush() +#define emberAfMessagingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER) ) { x; } +#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMessagingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer)) +#else +#define emberAfMessagingClusterPrint(...) +#define emberAfMessagingClusterPrintln(...) +#define emberAfMessagingClusterFlush() +#define emberAfMessagingClusterDebugExec(x) +#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfMessagingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER) + + +// Printing macros for cluster: Tunneling +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER) +#define emberAfTunnelingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__) +#define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfTunnelingClusterFlush() +#define emberAfTunnelingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER) ) { x; } +#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTunnelingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer)) +#else +#define emberAfTunnelingClusterPrint(...) +#define emberAfTunnelingClusterPrintln(...) +#define emberAfTunnelingClusterFlush() +#define emberAfTunnelingClusterDebugExec(x) +#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfTunnelingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER) + + +// Printing macros for cluster: Prepayment +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) +#define emberAfPrepaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__) +#define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPrepaymentClusterFlush() +#define emberAfPrepaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) ) { x; } +#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPrepaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer)) +#else +#define emberAfPrepaymentClusterPrint(...) +#define emberAfPrepaymentClusterPrintln(...) +#define emberAfPrepaymentClusterFlush() +#define emberAfPrepaymentClusterDebugExec(x) +#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPrepaymentClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) + + +// Printing macros for cluster: Energy Management +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) +#define emberAfEnergyManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__) +#define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfEnergyManagementClusterFlush() +#define emberAfEnergyManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) ) { x; } +#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEnergyManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer)) +#else +#define emberAfEnergyManagementClusterPrint(...) +#define emberAfEnergyManagementClusterPrintln(...) +#define emberAfEnergyManagementClusterFlush() +#define emberAfEnergyManagementClusterDebugExec(x) +#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfEnergyManagementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) + + +// Printing macros for cluster: Calendar +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER) +#define emberAfCalendarClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__) +#define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCalendarClusterFlush() +#define emberAfCalendarClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER) ) { x; } +#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCalendarClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer)) +#else +#define emberAfCalendarClusterPrint(...) +#define emberAfCalendarClusterPrintln(...) +#define emberAfCalendarClusterFlush() +#define emberAfCalendarClusterDebugExec(x) +#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) +#define emberAfCalendarClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER) + + +// Printing macros for cluster: Device Management +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) +#define emberAfDeviceManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__) +#define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDeviceManagementClusterFlush() +#define emberAfDeviceManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) ) { x; } +#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDeviceManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer)) +#else +#define emberAfDeviceManagementClusterPrint(...) +#define emberAfDeviceManagementClusterPrintln(...) +#define emberAfDeviceManagementClusterFlush() +#define emberAfDeviceManagementClusterDebugExec(x) +#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDeviceManagementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) + + +// Printing macros for cluster: Events +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER) +#define emberAfEventsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__) +#define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfEventsClusterFlush() +#define emberAfEventsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER) ) { x; } +#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEventsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer)) +#else +#define emberAfEventsClusterPrint(...) +#define emberAfEventsClusterPrintln(...) +#define emberAfEventsClusterFlush() +#define emberAfEventsClusterDebugExec(x) +#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) +#define emberAfEventsClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER) + + +// Printing macros for cluster: MDU Pairing +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) +#define emberAfMduPairingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__) +#define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfMduPairingClusterFlush() +#define emberAfMduPairingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) ) { x; } +#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMduPairingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer)) +#else +#define emberAfMduPairingClusterPrint(...) +#define emberAfMduPairingClusterPrintln(...) +#define emberAfMduPairingClusterFlush() +#define emberAfMduPairingClusterDebugExec(x) +#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfMduPairingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) + + +// Printing macros for cluster: Sub-GHz +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) +#define emberAfSubGhzClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__) +#define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSubGhzClusterFlush() +#define emberAfSubGhzClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) ) { x; } +#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSubGhzClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer)) +#else +#define emberAfSubGhzClusterPrint(...) +#define emberAfSubGhzClusterPrintln(...) +#define emberAfSubGhzClusterFlush() +#define emberAfSubGhzClusterDebugExec(x) +#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSubGhzClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) + + +// Printing macros for cluster: Key Establishment +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) +#define emberAfKeyEstablishmentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__) +#define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfKeyEstablishmentClusterFlush() +#define emberAfKeyEstablishmentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) ) { x; } +#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfKeyEstablishmentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer)) +#else +#define emberAfKeyEstablishmentClusterPrint(...) +#define emberAfKeyEstablishmentClusterPrintln(...) +#define emberAfKeyEstablishmentClusterFlush() +#define emberAfKeyEstablishmentClusterDebugExec(x) +#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) +#define emberAfKeyEstablishmentClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) + + +// Printing macros for cluster: Information +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER) +#define emberAfInformationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__) +#define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfInformationClusterFlush() +#define emberAfInformationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER) ) { x; } +#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfInformationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer)) +#else +#define emberAfInformationClusterPrint(...) +#define emberAfInformationClusterPrintln(...) +#define emberAfInformationClusterFlush() +#define emberAfInformationClusterDebugExec(x) +#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfInformationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER) + + +// Printing macros for cluster: Data Sharing +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) +#define emberAfDataSharingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__) +#define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDataSharingClusterFlush() +#define emberAfDataSharingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) ) { x; } +#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDataSharingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer)) +#else +#define emberAfDataSharingClusterPrint(...) +#define emberAfDataSharingClusterPrintln(...) +#define emberAfDataSharingClusterFlush() +#define emberAfDataSharingClusterDebugExec(x) +#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDataSharingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) + + +// Printing macros for cluster: Gaming +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER) +#define emberAfGamingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__) +#define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfGamingClusterFlush() +#define emberAfGamingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER) ) { x; } +#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGamingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer)) +#else +#define emberAfGamingClusterPrint(...) +#define emberAfGamingClusterPrintln(...) +#define emberAfGamingClusterFlush() +#define emberAfGamingClusterDebugExec(x) +#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfGamingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER) + + +// Printing macros for cluster: Data Rate Control +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) +#define emberAfDataRateControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDataRateControlClusterFlush() +#define emberAfDataRateControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) ) { x; } +#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDataRateControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer)) +#else +#define emberAfDataRateControlClusterPrint(...) +#define emberAfDataRateControlClusterPrintln(...) +#define emberAfDataRateControlClusterFlush() +#define emberAfDataRateControlClusterDebugExec(x) +#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDataRateControlClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) + + +// Printing macros for cluster: Voice over ZigBee +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) +#define emberAfVoiceOverZigbeeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__) +#define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfVoiceOverZigbeeClusterFlush() +#define emberAfVoiceOverZigbeeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) ) { x; } +#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfVoiceOverZigbeeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer)) +#else +#define emberAfVoiceOverZigbeeClusterPrint(...) +#define emberAfVoiceOverZigbeeClusterPrintln(...) +#define emberAfVoiceOverZigbeeClusterFlush() +#define emberAfVoiceOverZigbeeClusterDebugExec(x) +#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) +#define emberAfVoiceOverZigbeeClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) + + +// Printing macros for cluster: Chatting +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER) +#define emberAfChattingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__) +#define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfChattingClusterFlush() +#define emberAfChattingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER) ) { x; } +#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChattingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer)) +#else +#define emberAfChattingClusterPrint(...) +#define emberAfChattingClusterPrintln(...) +#define emberAfChattingClusterFlush() +#define emberAfChattingClusterDebugExec(x) +#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfChattingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER) + + +// Printing macros for cluster: Payment +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER) +#define emberAfPaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__) +#define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfPaymentClusterFlush() +#define emberAfPaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER) ) { x; } +#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer)) +#else +#define emberAfPaymentClusterPrint(...) +#define emberAfPaymentClusterPrintln(...) +#define emberAfPaymentClusterFlush() +#define emberAfPaymentClusterDebugExec(x) +#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) +#define emberAfPaymentClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER) + + +// Printing macros for cluster: Billing +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER) +#define emberAfBillingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__) +#define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfBillingClusterFlush() +#define emberAfBillingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER) ) { x; } +#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBillingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer)) +#else +#define emberAfBillingClusterPrint(...) +#define emberAfBillingClusterPrintln(...) +#define emberAfBillingClusterFlush() +#define emberAfBillingClusterDebugExec(x) +#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) +#define emberAfBillingClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER) + + +// Printing macros for cluster: Appliance Identification +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) +#define emberAfApplianceIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__) +#define emberAfApplianceIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfApplianceIdentificationClusterFlush() +#define emberAfApplianceIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) ) { x; } +#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer)) +#else +#define emberAfApplianceIdentificationClusterPrint(...) +#define emberAfApplianceIdentificationClusterPrintln(...) +#define emberAfApplianceIdentificationClusterFlush() +#define emberAfApplianceIdentificationClusterDebugExec(x) +#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfApplianceIdentificationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) + + +// Printing macros for cluster: Meter Identification +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) +#define emberAfMeterIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__) +#define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfMeterIdentificationClusterFlush() +#define emberAfMeterIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) ) { x; } +#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMeterIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer)) +#else +#define emberAfMeterIdentificationClusterPrint(...) +#define emberAfMeterIdentificationClusterPrintln(...) +#define emberAfMeterIdentificationClusterFlush() +#define emberAfMeterIdentificationClusterDebugExec(x) +#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfMeterIdentificationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) + + +// Printing macros for cluster: Appliance Events and Alert +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) +#define emberAfApplianceEventsAndAlertClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__) +#define emberAfApplianceEventsAndAlertClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfApplianceEventsAndAlertClusterFlush() +#define emberAfApplianceEventsAndAlertClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) ) { x; } +#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceEventsAndAlertClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer)) +#else +#define emberAfApplianceEventsAndAlertClusterPrint(...) +#define emberAfApplianceEventsAndAlertClusterPrintln(...) +#define emberAfApplianceEventsAndAlertClusterFlush() +#define emberAfApplianceEventsAndAlertClusterDebugExec(x) +#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) +#define emberAfApplianceEventsAndAlertClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) + + +// Printing macros for cluster: Appliance Statistics +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) +#define emberAfApplianceStatisticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__) +#define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfApplianceStatisticsClusterFlush() +#define emberAfApplianceStatisticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) ) { x; } +#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceStatisticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer)) +#else +#define emberAfApplianceStatisticsClusterPrint(...) +#define emberAfApplianceStatisticsClusterPrintln(...) +#define emberAfApplianceStatisticsClusterFlush() +#define emberAfApplianceStatisticsClusterDebugExec(x) +#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) +#define emberAfApplianceStatisticsClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) + + +// Printing macros for cluster: Electrical Measurement +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) +#define emberAfElectricalMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfElectricalMeasurementClusterFlush() +#define emberAfElectricalMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) ) { x; } +#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfElectricalMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer)) +#else +#define emberAfElectricalMeasurementClusterPrint(...) +#define emberAfElectricalMeasurementClusterPrintln(...) +#define emberAfElectricalMeasurementClusterFlush() +#define emberAfElectricalMeasurementClusterDebugExec(x) +#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) +#define emberAfElectricalMeasurementClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) + + +// Printing macros for cluster: Diagnostics +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) +#define emberAfDiagnosticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__) +#define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDiagnosticsClusterFlush() +#define emberAfDiagnosticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) ) { x; } +#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDiagnosticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer)) +#else +#define emberAfDiagnosticsClusterPrint(...) +#define emberAfDiagnosticsClusterPrintln(...) +#define emberAfDiagnosticsClusterFlush() +#define emberAfDiagnosticsClusterDebugExec(x) +#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) +#define emberAfDiagnosticsClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) + + +// Printing macros for cluster: ZLL Commissioning +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) +#define emberAfZllCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__) +#define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfZllCommissioningClusterFlush() +#define emberAfZllCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) ) { x; } +#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfZllCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer)) +#else +#define emberAfZllCommissioningClusterPrint(...) +#define emberAfZllCommissioningClusterPrintln(...) +#define emberAfZllCommissioningClusterFlush() +#define emberAfZllCommissioningClusterDebugExec(x) +#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) +#define emberAfZllCommissioningClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) + + +// Printing macros for cluster: Sample Mfg Specific Cluster +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) +#define emberAfSampleMfgSpecificClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__) +#define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSampleMfgSpecificClusterFlush() +#define emberAfSampleMfgSpecificClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) ) { x; } +#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSampleMfgSpecificClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer)) +#else +#define emberAfSampleMfgSpecificClusterPrint(...) +#define emberAfSampleMfgSpecificClusterPrintln(...) +#define emberAfSampleMfgSpecificClusterFlush() +#define emberAfSampleMfgSpecificClusterDebugExec(x) +#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSampleMfgSpecificClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) + + +// Printing macros for cluster: Sample Mfg Specific Cluster 2 +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) +#define emberAfSampleMfgSpecificCluster2Print(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__) +#define emberAfSampleMfgSpecificCluster2Println(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSampleMfgSpecificCluster2Flush() +#define emberAfSampleMfgSpecificCluster2DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) ) { x; } +#define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer), (len), (withSpace)) +#define emberAfSampleMfgSpecificCluster2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer)) +#else +#define emberAfSampleMfgSpecificCluster2Print(...) +#define emberAfSampleMfgSpecificCluster2Println(...) +#define emberAfSampleMfgSpecificCluster2Flush() +#define emberAfSampleMfgSpecificCluster2DebugExec(x) +#define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace) +#define emberAfSampleMfgSpecificCluster2PrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) + + +// Printing macros for cluster: Configuration Cluster +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) +#define emberAfOtaConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__) +#define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfOtaConfigurationClusterFlush() +#define emberAfOtaConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) ) { x; } +#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOtaConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer)) +#else +#define emberAfOtaConfigurationClusterPrint(...) +#define emberAfOtaConfigurationClusterPrintln(...) +#define emberAfOtaConfigurationClusterFlush() +#define emberAfOtaConfigurationClusterDebugExec(x) +#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) +#define emberAfOtaConfigurationClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) + + +// Printing macros for cluster: MFGLIB Cluster +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER) +#define emberAfMfglibClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__) +#define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfMfglibClusterFlush() +#define emberAfMfglibClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER) ) { x; } +#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMfglibClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer)) +#else +#define emberAfMfglibClusterPrint(...) +#define emberAfMfglibClusterPrintln(...) +#define emberAfMfglibClusterFlush() +#define emberAfMfglibClusterDebugExec(x) +#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) +#define emberAfMfglibClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER) + + +// Printing macros for cluster: SL Works With All Hubs +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER) +#define emberAfSlWwahClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__) +#define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSlWwahClusterFlush() +#define emberAfSlWwahClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER) ) { x; } +#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSlWwahClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer)) +#else +#define emberAfSlWwahClusterPrint(...) +#define emberAfSlWwahClusterPrintln(...) +#define emberAfSlWwahClusterFlush() +#define emberAfSlWwahClusterDebugExec(x) +#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) +#define emberAfSlWwahClusterPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER) + + +// Printing macros for Core +// Prints messages for global flow of the receive/send +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE) +#define emberAfCorePrint(...) emberAfPrint(EMBER_AF_PRINT_CORE, __VA_ARGS__) +#define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCoreFlush() +#define emberAfCoreDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CORE) ) { x; } +#define emberAfCorePrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CORE, (buffer), (len), (withSpace)) +#define emberAfCorePrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CORE, (buffer)) +#else +#define emberAfCorePrint(...) +#define emberAfCorePrintln(...) +#define emberAfCoreFlush() +#define emberAfCoreDebugExec(x) +#define emberAfCorePrintBuffer(buffer, len, withSpace) +#define emberAfCorePrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE) + + +// Printing macros for Debug +// Prints messages for random debugging +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG) +#define emberAfDebugPrint(...) emberAfPrint(EMBER_AF_PRINT_DEBUG, __VA_ARGS__) +#define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfDebugFlush() +#define emberAfDebugDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG) ) { x; } +#define emberAfDebugPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEBUG, (buffer), (len), (withSpace)) +#define emberAfDebugPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEBUG, (buffer)) +#else +#define emberAfDebugPrint(...) +#define emberAfDebugPrintln(...) +#define emberAfDebugFlush() +#define emberAfDebugDebugExec(x) +#define emberAfDebugPrintBuffer(buffer, len, withSpace) +#define emberAfDebugPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG) + + +// Printing macros for Application +// Prints messages for application part +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) +#define emberAfAppPrint(...) emberAfPrint(EMBER_AF_PRINT_APP, __VA_ARGS__) +#define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfAppFlush() +#define emberAfAppDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APP) ) { x; } +#define emberAfAppPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APP, (buffer), (len), (withSpace)) +#define emberAfAppPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APP, (buffer)) +#else +#define emberAfAppPrint(...) +#define emberAfAppPrintln(...) +#define emberAfAppFlush() +#define emberAfAppDebugExec(x) +#define emberAfAppPrintBuffer(buffer, len, withSpace) +#define emberAfAppPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) + + +// Printing macros for Security +// Prints messages related to security +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY) +#define emberAfSecurityPrint(...) emberAfPrint(EMBER_AF_PRINT_SECURITY, __VA_ARGS__) +#define emberAfSecurityPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SECURITY, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfSecurityFlush() +#define emberAfSecurityDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SECURITY) ) { x; } +#define emberAfSecurityPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SECURITY, (buffer), (len), (withSpace)) +#define emberAfSecurityPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SECURITY, (buffer)) +#else +#define emberAfSecurityPrint(...) +#define emberAfSecurityPrintln(...) +#define emberAfSecurityFlush() +#define emberAfSecurityDebugExec(x) +#define emberAfSecurityPrintBuffer(buffer, len, withSpace) +#define emberAfSecurityPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY) + + +// Printing macros for Attributes +// Prints messages related to attributes +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) +#define emberAfAttributesPrint(...) emberAfPrint(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__) +#define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfAttributesFlush() +#define emberAfAttributesDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES) ) { x; } +#define emberAfAttributesPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace)) +#define emberAfAttributesPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ATTRIBUTES, (buffer)) +#else +#define emberAfAttributesPrint(...) +#define emberAfAttributesPrintln(...) +#define emberAfAttributesFlush() +#define emberAfAttributesDebugExec(x) +#define emberAfAttributesPrintBuffer(buffer, len, withSpace) +#define emberAfAttributesPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) + + +// Printing macros for Reporting +// Prints messages related to reporting +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING) +#define emberAfReportingPrint(...) emberAfPrint(EMBER_AF_PRINT_REPORTING, __VA_ARGS__) +#define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfReportingFlush() +#define emberAfReportingDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING) ) { x; } +#define emberAfReportingPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace)) +#define emberAfReportingPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REPORTING, (buffer)) +#else +#define emberAfReportingPrint(...) +#define emberAfReportingPrintln(...) +#define emberAfReportingFlush() +#define emberAfReportingDebugExec(x) +#define emberAfReportingPrintBuffer(buffer, len, withSpace) +#define emberAfReportingPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING) + + +// Printing macros for Service discovery +// Prints messages related to service discovery +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY) +#define emberAfServiceDiscoveryPrint(...) emberAfPrint(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__) +#define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfServiceDiscoveryFlush() +#define emberAfServiceDiscoveryDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY) ) { x; } +#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace)) +#define emberAfServiceDiscoveryPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer)) +#else +#define emberAfServiceDiscoveryPrint(...) +#define emberAfServiceDiscoveryPrintln(...) +#define emberAfServiceDiscoveryFlush() +#define emberAfServiceDiscoveryDebugExec(x) +#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) +#define emberAfServiceDiscoveryPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY) + + +// Printing macros for Registration +// Prints messages related to registration +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION) +#define emberAfRegistrationPrint(...) emberAfPrint(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__) +#define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfRegistrationFlush() +#define emberAfRegistrationDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION) ) { x; } +#define emberAfRegistrationPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace)) +#define emberAfRegistrationPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REGISTRATION, (buffer)) +#else +#define emberAfRegistrationPrint(...) +#define emberAfRegistrationPrintln(...) +#define emberAfRegistrationFlush() +#define emberAfRegistrationDebugExec(x) +#define emberAfRegistrationPrintBuffer(buffer, len, withSpace) +#define emberAfRegistrationPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION) + + +// Printing macros for ZDO (ZigBee Device Object) +// Prints messages related to ZDO functionality +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO) +#define emberAfZdoPrint(...) emberAfPrint(EMBER_AF_PRINT_ZDO, __VA_ARGS__) +#define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfZdoFlush() +#define emberAfZdoDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZDO) ) { x; } +#define emberAfZdoPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZDO, (buffer), (len), (withSpace)) +#define emberAfZdoPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZDO, (buffer)) +#else +#define emberAfZdoPrint(...) +#define emberAfZdoPrintln(...) +#define emberAfZdoFlush() +#define emberAfZdoDebugExec(x) +#define emberAfZdoPrintBuffer(buffer, len, withSpace) +#define emberAfZdoPrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO) + + +// Printing macros for Custom messages (1) +// Messages that can be used by the end developer +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1) +#define emberAfCustom1Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__) +#define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCustom1Flush() +#define emberAfCustom1DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1) ) { x; } +#define emberAfCustom1PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM1, (buffer), (len), (withSpace)) +#define emberAfCustom1PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM1, (buffer)) +#else +#define emberAfCustom1Print(...) +#define emberAfCustom1Println(...) +#define emberAfCustom1Flush() +#define emberAfCustom1DebugExec(x) +#define emberAfCustom1PrintBuffer(buffer, len, withSpace) +#define emberAfCustom1PrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1) + + +// Printing macros for Custom messages (2) +// Messages that can be used by the end developer +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2) +#define emberAfCustom2Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__) +#define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCustom2Flush() +#define emberAfCustom2DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2) ) { x; } +#define emberAfCustom2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM2, (buffer), (len), (withSpace)) +#define emberAfCustom2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM2, (buffer)) +#else +#define emberAfCustom2Print(...) +#define emberAfCustom2Println(...) +#define emberAfCustom2Flush() +#define emberAfCustom2DebugExec(x) +#define emberAfCustom2PrintBuffer(buffer, len, withSpace) +#define emberAfCustom2PrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2) + + +// Printing macros for Custom messages (3) +// Messages that can be used by the end developer +#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3) +#define emberAfCustom3Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__) +#define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__) +// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. +#define emberAfCustom3Flush() +#define emberAfCustom3DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3) ) { x; } +#define emberAfCustom3PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM3, (buffer), (len), (withSpace)) +#define emberAfCustom3PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM3, (buffer)) +#else +#define emberAfCustom3Print(...) +#define emberAfCustom3Println(...) +#define emberAfCustom3Flush() +#define emberAfCustom3DebugExec(x) +#define emberAfCustom3PrintBuffer(buffer, len, withSpace) +#define emberAfCustom3PrintString(buffer) +#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3) + + +#endif // SILABS_EMBER_AF_DEBUG_PRINTING diff --git a/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h b/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h new file mode 100644 index 00000000000000..23f6f25abafb14 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h @@ -0,0 +1,140 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_AF_ENDPOINT_CONFIG +#define SILABS_AF_ENDPOINT_CONFIG + + +// Fixed number of defined endpoints +#define FIXED_ENDPOINT_COUNT (1) + + + + +// Generated attributes +#define GENERATED_ATTRIBUTES { \ + { 0x0000, ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, (0x00), { (uint8_t*)0x00 } }, /* 0 / On/off / on/off*/\ + { 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t*)0x0001 } }, /* 1 / On/off / cluster revision*/\ + } + + +// Cluster function static arrays +#define GENERATED_FUNCTION_ARRAYS \ + + +// Clusters definitions +#define GENERATED_CLUSTERS { \ + { 0x0006, (EmberAfAttributeMetadata*)&(generatedAttributes[0]), 2, 3, (CLUSTER_MASK_SERVER), NULL, }, \ + } + + +// Endpoint types +#define GENERATED_ENDPOINT_TYPES { \ + { (EmberAfCluster*)&(generatedClusters[0]), 1, 3 }, \ + } + + +// Cluster manufacturer codes +#define GENERATED_CLUSTER_MANUFACTURER_CODES { \ +{0x00, 0x00} \ + } +#define GENERATED_CLUSTER_MANUFACTURER_CODE_COUNT (0) + +// Attribute manufacturer codes +#define GENERATED_ATTRIBUTE_MANUFACTURER_CODES { \ +{0x00, 0x00} \ + } +#define GENERATED_ATTRIBUTE_MANUFACTURER_CODE_COUNT (0) + + +// Largest attribute size is needed for various buffers +#define ATTRIBUTE_LARGEST (2) +// Total size of singleton attributes +#define ATTRIBUTE_SINGLETONS_SIZE (0) + +// Total size of attribute storage +#define ATTRIBUTE_MAX_SIZE 3 + +// Array of endpoints that are supported +#define FIXED_ENDPOINT_ARRAY { 1 } + +// Array of profile ids +#define FIXED_PROFILE_IDS { 65535 } + +// Array of device ids +#define FIXED_DEVICE_IDS { 65535 } + +// Array of device versions +#define FIXED_DEVICE_VERSIONS { 1 } + +// Array of endpoint types supported on each endpoint +#define FIXED_ENDPOINT_TYPES { 0 } + +// Array of networks supported on each endpoint +#define FIXED_NETWORKS { 0 } + + +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_DECLARATIONS \ + void emberAfPluginNetworkSteeringStackStatusCallback(EmberStatus status); \ + + +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_CALLS \ + emberAfPluginNetworkSteeringStackStatusCallback(status); \ + + +// Generated data for the command discovery +#define GENERATED_COMMANDS { \ + { 0x0006, 0x00, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Off */ \ + { 0x0006, 0x01, COMMAND_MASK_INCOMING_SERVER }, /* On/off / On */ \ + { 0x0006, 0x02, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Toggle */ \ + } +#define EMBER_AF_GENERATED_COMMAND_COUNT (3) + +// Command manufacturer codes +#define GENERATED_COMMAND_MANUFACTURER_CODES { \ +{0x00, 0x00} \ + } +#define GENERATED_COMMAND_MANUFACTURER_CODE_COUNT (0) + + +// Generated reporting configuration defaults +#define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS {\ + { EMBER_ZCL_REPORTING_DIRECTION_REPORTED, 1, 0x0006, 0x0000, CLUSTER_MASK_SERVER, 0x0000, 1, 65534, 0 }, \ +} +#define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS_TABLE_SIZE (1) +#endif // SILABS_AF_ENDPOINT_CONFIG diff --git a/examples/wifi-echo/server/esp32/main/gen/enums.h b/examples/wifi-echo/server/esp32/main/gen/enums.h new file mode 100644 index 00000000000000..5d0011b9df4802 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/enums.h @@ -0,0 +1,3359 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_ENUMS +#define SILABS_EMBER_AF_ENUMS + + +/** + * @addtogroup enums Application Framework Enums Reference + * This header provides Application Framework enum definitions. + * @{ + */ +/** @name Enums */ +// @{ + +typedef enum { + EMBER_ZCL_11073_CONNECT_REQUEST_CONNECT_CONTROL_PREEMPTIBLE = 0x01, +} EmberAf11073ConnectRequestConnectControl; + +typedef enum { + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_DISCONNECTED = 0x00, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_CONNECTED = 0x01, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_NOT_AUTHORIZED = 0x02, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_RECONNECT_REQUEST = 0x03, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_ALREADY_CONNECTED = 0x04, +} EmberAf11073TunnelConnectionStatus; + +typedef enum { + EMBER_ZCL_ALERT_COUNT_TYPE_UNSTRUCTURED = 0x00, +} EmberAfAlertCountType; + +typedef enum { + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_WARNING = 0x0100, + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_DANGER = 0x0200, + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_FAILURE = 0x0300, +} EmberAfAlertStructureCategory; + +typedef enum { + EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_RECOVERY = 0x0000, + EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_PRESENCE = 0x1000, +} EmberAfAlertStructurePresenceRecovery; + +typedef enum { + EMBER_ZCL_ALTERNATE_COST_UNIT_KG_OF_CO2_PER_UNIT_OF_MEASURE = 0x02, +} EmberAfAlternateCostUnit; + +typedef enum { + EMBER_ZCL_AMI_CRITICALITY_LEVEL_RESERVED = 0x00, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_GREEN = 0x01, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_1 = 0x02, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_2 = 0x03, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_3 = 0x04, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_4 = 0x05, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_5 = 0x06, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_EMERGENCY = 0x07, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_PLANNED_OUTAGE = 0x08, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_SERVICE_DISCONNECT = 0x09, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED1 = 0x0A, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED2 = 0x0B, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED3 = 0x0C, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED4 = 0x0D, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED5 = 0x0E, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED6 = 0x0F, +} EmberAfAmiCriticalityLevel; + +typedef enum { + EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_RX = 0x01, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_STARTED = 0x02, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED = 0x03, + EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_OUT = 0x04, + EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_IN = 0x05, + EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_CANCELED = 0x06, + EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_SUPERSEDED = 0x07, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_WITH_USER_OPT_OUT = 0x08, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_DUE_TO_USER_OPT_IN = 0x09, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED_NO_USER_PARTICIPATION_PREVIOUS_OPT_OUT = 0x0A, + EMBER_ZCL_AMI_EVENT_STATUS_INVALID_OPT_OUT = 0xF6, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_NOT_FOUND = 0xF7, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND = 0xF8, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND_INVALID_EFFECTIVE_TIME = 0xF9, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_EVENT_EXPIRED = 0xFB, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_UNDEFINED_EVENT = 0xFD, + EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_REJECTED = 0xFE, +} EmberAfAmiEventStatus; + +typedef enum { + EMBER_ZCL_AMI_GET_PROFILE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_UNDEFINED_INTERVAL_CHANNEL_REQUESTED = 0x01, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_INTERVAL_CHANNEL_NOT_SUPPORTED = 0x02, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_INVALID_END_TIME = 0x03, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_MORE_PERIODS_REQUESTED_THAN_CAN_BE_RETURNED = 0x04, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_NO_INTERVALS_AVAILABLE_FOR_THE_REQUESTED_TIME = 0x05, +} EmberAfAmiGetProfileStatus; + +typedef enum { + EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_DELIVERED = 0x00, + EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_RECEIVED = 0x01, +} EmberAfAmiIntervalChannel; + +typedef enum { + EMBER_ZCL_AMI_INTERVAL_PERIOD_DAILY = 0x00, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES60 = 0x01, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES30 = 0x02, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES15 = 0x03, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES10 = 0x04, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES7P5 = 0x05, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES5 = 0x06, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES2P5 = 0x07, +} EmberAfAmiIntervalPeriod; + +typedef enum { + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_SUCCESS = 0x00, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNKNOWN_ISSUER = 0x01, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_KEY_CONFIRM = 0x02, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_MESSAGE = 0x03, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_NO_RESOURCES = 0x04, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNSUPPORTED_SUITE = 0x05, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_INVALID_KEY_USAGE = 0x06, +} EmberAfAmiKeyEstablishmentStatus; + +typedef enum { + EMBER_ZCL_AMI_REGISTRATION_STATE_UNREGISTERED = 0x00, + EMBER_ZCL_AMI_REGISTRATION_STATE_JOINING_NETWORK = 0x01, + EMBER_ZCL_AMI_REGISTRATION_STATE_JOINED_NETWORK = 0x02, + EMBER_ZCL_AMI_REGISTRATION_STATE_SUBMITTED_REGISTRATION_REQUEST = 0x03, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTRATION_REJECTED = 0x04, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERED = 0x05, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERATION_NOT_POSSIBLE = 0x06, +} EmberAfAmiRegistrationState; + +typedef enum { + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS = 0x00, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR = 0x01, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR = 0x02, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR = 0x03, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR = 0x04, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR = 0x05, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR = 0x06, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR = 0x07, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GAUGE = 0x08, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE = 0x09, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND = 0x0A, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS = 0x0B, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND = 0x0C, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS = 0x0D, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS_BCD = 0x80, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR_BCD = 0x81, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR_BCD = 0x82, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR_BCD = 0x83, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR_BCD = 0x84, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR_BCD = 0x85, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR_BCD = 0x86, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR_BCD = 0x87, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GUAGE_BCD = 0x88, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE_BCD = 0x89, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND_BCD = 0x8A, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS_BCD = 0x8B, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND_BCD = 0x8C, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS_BCD = 0x8D, +} EmberAfAmiUnitOfMeasure; + +typedef enum { + EMBER_ZCL_ANONYMOUS_DATA_STATE_NO_SOURCE_FOUND = 0x00, + EMBER_ZCL_ANONYMOUS_DATA_STATE_SOURCE_FOUND = 0x01, +} EmberAfAnonymousDataState; + +typedef enum { + EMBER_ZCL_APPLIANCE_STATUS_OFF = 0x01, + EMBER_ZCL_APPLIANCE_STATUS_STAND_BY = 0x02, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED = 0x03, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED_WAITING_TO_START = 0x04, + EMBER_ZCL_APPLIANCE_STATUS_RUNNING = 0x05, + EMBER_ZCL_APPLIANCE_STATUS_PAUSE = 0x06, + EMBER_ZCL_APPLIANCE_STATUS_END_PROGRAMMED = 0x07, + EMBER_ZCL_APPLIANCE_STATUS_FAILURE = 0x08, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMME_INTERRUPTED = 0x09, + EMBER_ZCL_APPLIANCE_STATUS_IDLE = 0x0A, + EMBER_ZCL_APPLIANCE_STATUS_RINSE_HOLD = 0x0B, + EMBER_ZCL_APPLIANCE_STATUS_SERVICE = 0x0C, + EMBER_ZCL_APPLIANCE_STATUS_SUPERFREEZING = 0x0D, + EMBER_ZCL_APPLIANCE_STATUS_SUPERCOOLING = 0x0E, + EMBER_ZCL_APPLIANCE_STATUS_SUPERHEATING = 0x0F, +} EmberAfApplianceStatus; + +typedef enum { + EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_PENDING = 0x00, + EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_ATTRIBUTE_REPORTING_COMPLETE = 0x01, +} EmberAfAttributeReportingStatus; + +typedef enum { + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_DENY_WRITE = 0x00, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL = 0x01, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY = 0x02, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_UNSUPPORTED_ATTRIBUTE = 0x86, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_VALUE = 0x87, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_READ_ONLY = 0x88, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_DATA_TYPE = 0x8D, +} EmberAfAttributeWritePermission; + +typedef enum { + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_CLOSED = 0x00, + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_OPEN = 0x64, + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_UNKNOWN = 0xFF, +} EmberAfBarrierControlBarrierPosition; + +typedef enum { + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_STOPPED = 0x00, + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_CLOSING = 0x01, + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_OPENING = 0x02, +} EmberAfBarrierControlMovingState; + +typedef enum { + EMBER_ZCL_BATTERY_SIZE_NO_BATTERY = 0x00, + EMBER_ZCL_BATTERY_SIZE_BUILT_IN = 0x01, + EMBER_ZCL_BATTERY_SIZE_OTHER = 0x02, + EMBER_ZCL_BATTERY_SIZE_AA = 0x03, + EMBER_ZCL_BATTERY_SIZE_AAA = 0x04, + EMBER_ZCL_BATTERY_SIZE_C = 0x05, + EMBER_ZCL_BATTERY_SIZE_D = 0x06, + EMBER_ZCL_BATTERY_SIZE_UNKNOWN = 0xFF, +} EmberAfBatterySize; + +typedef enum { + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MINUTES = 0x000000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_DAYS = 0x400000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_WEEKS = 0x800000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MONTHS = 0xC00000, +} EmberAfBillingPeriodDurationUnits; + +typedef enum { + EMBER_ZCL_BLOCK_NO_BLOCKS_IN_USE = 0x00, + EMBER_ZCL_BLOCK_BLOCK1 = 0x01, + EMBER_ZCL_BLOCK_BLOCK2 = 0x02, + EMBER_ZCL_BLOCK_BLOCK3 = 0x03, + EMBER_ZCL_BLOCK_BLOCK4 = 0x04, + EMBER_ZCL_BLOCK_BLOCK5 = 0x05, + EMBER_ZCL_BLOCK_BLOCK6 = 0x06, + EMBER_ZCL_BLOCK_BLOCK7 = 0x07, + EMBER_ZCL_BLOCK_BLOCK8 = 0x08, + EMBER_ZCL_BLOCK_BLOCK9 = 0x09, + EMBER_ZCL_BLOCK_BLOCK10 = 0x0A, + EMBER_ZCL_BLOCK_BLOCK11 = 0x0B, + EMBER_ZCL_BLOCK_BLOCK12 = 0x0C, + EMBER_ZCL_BLOCK_BLOCK13 = 0x0D, + EMBER_ZCL_BLOCK_BLOCK14 = 0x0E, + EMBER_ZCL_BLOCK_BLOCK15 = 0x0F, + EMBER_ZCL_BLOCK_BLOCK16 = 0x10, +} EmberAfBlock; + +typedef enum { + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_START_OF_TIMEBASE = 0x00, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_END_OF_TIMEBASE = 0x10, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_NOT_SPECIFIED = 0x20, +} EmberAfBlockPeriodDurationTypeControl; + +typedef enum { + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MINUTES = 0x00, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_DAYS = 0x01, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_WEEKS = 0x02, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MONTHS = 0x03, +} EmberAfBlockPeriodDurationTypeTimebase; + +typedef enum { + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_KILOWATT_HOUR = 0x01, + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_GALLON_OF_GASOLINE = 0x02, + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_THERM_OF_NATURAL_GAS = 0x03, +} EmberAfCO2Unit; + +typedef enum { + EMBER_ZCL_CALENDAR_TIME_REFERENCE_UTC_TIME = 0x00, + EMBER_ZCL_CALENDAR_TIME_REFERENCE_STANDARD_TIME = 0x01, + EMBER_ZCL_CALENDAR_TIME_REFERENCE_LOCAL_TIME = 0x02, +} EmberAfCalendarTimeReference; + +typedef enum { + EMBER_ZCL_CALENDAR_TYPE_DELIVERED_CALENDAR = 0x00, + EMBER_ZCL_CALENDAR_TYPE_RECEIVED_CALENDAR = 0x01, + EMBER_ZCL_CALENDAR_TYPE_DELIVERED_AND_RECEIVED_CALENDAR = 0x02, + EMBER_ZCL_CALENDAR_TYPE_FRIENDLY_CREDIT_CALENDAR = 0x03, + EMBER_ZCL_CALENDAR_TYPE_AUXILLIARY_LOAD_SWITCH_CALENDAR = 0x04, +} EmberAfCalendarType; + +typedef enum { + EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_CUBIC_METER = 0x01, + EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_KILOGRAM = 0x02, +} EmberAfCalorificValueUnit; + +typedef enum { + EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_NOT_CERTIFIED = 0x10, + EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_CERTIFIED = 0x1A, +} EmberAfCecedSpecificationVersion; + +typedef enum { + EMBER_ZCL_COLOR_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, +} EmberAfColorControlOptions; + +typedef enum { + EMBER_ZCL_COLOR_LOOP_ACTION_DEACTIVATE = 0x00, + EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE = 0x01, + EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE = 0x02, +} EmberAfColorLoopAction; + +typedef enum { + EMBER_ZCL_COLOR_LOOP_DIRECTION_DECREMENT_HUE = 0x00, + EMBER_ZCL_COLOR_LOOP_DIRECTION_INCREMENT_HUE = 0x01, +} EmberAfColorLoopDirection; + +typedef enum { + EMBER_ZCL_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, + EMBER_ZCL_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, + EMBER_ZCL_COLOR_MODE_COLOR_TEMPERATURE = 0x02, +} EmberAfColorMode; + +typedef enum { + EMBER_ZCL_COMMAND_IDENTIFICATION_START = 0x01, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP = 0x02, + EMBER_ZCL_COMMAND_IDENTIFICATION_PAUSE = 0x03, + EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERFREEZING = 0x04, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERFREEZING = 0x05, + EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERCOOLING = 0x06, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERCOOLING = 0x07, + EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_GAS = 0x08, + EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_GAS = 0x09, + EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_ENERGY_CONTROL = 0x0A, + EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_ENERGY_CONTROL = 0x0B, +} EmberAfCommandIdentification; + +typedef enum { + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_NO_ACTION = 0x00, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_FORM_NETWORK = 0x01, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_REJOIN_NETWORK = 0x02, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_START_FROM_SCRATCH = 0x03, +} EmberAfCommissioningStartupControl; + +typedef enum { + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING = 0x00, + EMBER_ZCL_COMMODITY_TYPE_GAS_METERING = 0x01, + EMBER_ZCL_COMMODITY_TYPE_WATER_METERING = 0x02, + EMBER_ZCL_COMMODITY_TYPE_THERMAL_METERING = 0x03, + EMBER_ZCL_COMMODITY_TYPE_PRESSURE_METERING = 0x04, + EMBER_ZCL_COMMODITY_TYPE_HEAT_METERING = 0x05, + EMBER_ZCL_COMMODITY_TYPE_COOLING_METERING = 0x06, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, + EMBER_ZCL_COMMODITY_TYPE_PV_GENERATION_METERING = 0x08, + EMBER_ZCL_COMMODITY_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, + EMBER_ZCL_COMMODITY_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, + EMBER_ZCL_COMMODITY_TYPE_MICRO_GENERATION_METERING = 0x0B, + EMBER_ZCL_COMMODITY_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, +} EmberAfCommodityType; + +typedef enum { + EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_ACCEPTED = 0x01, + EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_REJECTED = 0x02, +} EmberAfCppEventResponseCppAuth; + +typedef enum { + EMBER_ZCL_CPP_PRICE_TIER_CPP1 = 0x00, + EMBER_ZCL_CPP_PRICE_TIER_CPP2 = 0x01, +} EmberAfCppPriceTier; + +typedef enum { + EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_INCREMENTAL = 0x00, + EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_ABSOLUTE = 0x01, +} EmberAfCreditAdjustmentType; + +typedef enum { + EMBER_ZCL_CREDIT_PAYMENT_STATUS_PENDING = 0x00, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_RECEIVED_PAID = 0x01, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_OVERDUE = 0x02, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_2_PAYMENTS_OVERDUE = 0x03, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_3_PAYMENTS_OVERDUE = 0x04, +} EmberAfCreditPaymentStatus; + +typedef enum { + EMBER_ZCL_DATA_QUALITY_ID_ALL_DATA_CERTIFIED = 0x0000, + EMBER_ZCL_DATA_QUALITY_ID_ONLY_INSTANTANEOUS_POWER_NOT_CERTIFIED = 0x0001, + EMBER_ZCL_DATA_QUALITY_ID_ONLY_CUMULATED_CONSUMPTION_NOT_CERTIFIED = 0x0002, + EMBER_ZCL_DATA_QUALITY_ID_NOT_CERTIFIED_DATA = 0x0003, +} EmberAfDataQualityId; + +typedef enum { + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_ABSOLUTE = 0x00, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_INCREMENTAL = 0x01, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_ABSOLUTE = 0x02, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_INCREMENTAL = 0x03, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_ABSOLUTE = 0x04, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_INCREMENTAL = 0x05, +} EmberAfDebtAmountType; + +typedef enum { + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_HOUR = 0x00, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_DAY = 0x01, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_WEEK = 0x02, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_MONTH = 0x03, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_QUARTER = 0x04, +} EmberAfDebtRecoveryFrequency; + +typedef enum { + EMBER_ZCL_DEBT_RECOVERY_METHOD_TIME_BASED = 0x00, + EMBER_ZCL_DEBT_RECOVERY_METHOD_PERCENTAGE_BASED = 0x01, + EMBER_ZCL_DEBT_RECOVERY_METHOD_CATCH_UP_BASED = 0x02, +} EmberAfDebtRecoveryMethod; + +typedef enum { + EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_NOT_ALLOWED = 0x00, + EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_ALLOWED = 0x01, +} EmberAfDehumidifcationLockout; + +typedef enum { + EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_NOT_SORTED = 0x00, + EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_TOP_OF_THE_LIST = 0x01, +} EmberAfDeviceInformationRecordSort; + +typedef enum { + EMBER_ZCL_DEVICE_STATUS2_STRUCTURE_IRIS_SYMPTOM_CODE = 0x20, +} EmberAfDeviceStatus2Structure; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_KEYPAD = 0x00, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RF = 0x01, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_MANUAL = 0x02, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RFID = 0x03, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_INDETERMINATE = 0xFF, +} EmberAfDoorLockEventSource; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_OPERATION = 0x00, + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_PROGRAMMING = 0x01, + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_ALARM = 0x02, +} EmberAfDoorLockEventType; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NORMAL_MODE = 0x00, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_VACATION_MODE = 0x01, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PRIVACY_MODE = 0x02, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NO_RF_LOCK_OR_UNLOCK = 0x03, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_LOCAL_PROGRAMMING_MODE = 0x04, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PASSAGE_MODE = 0x05, +} EmberAfDoorLockOperatingMode; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK = 0x01, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK = 0x02, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_PIN_OR_ID = 0x03, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_SCHEDULE = 0x04, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_PIN_OR_ID = 0x05, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_SCHEDULE = 0x06, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_ONE_TOUCH_LOCK = 0x07, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_LOCK = 0x08, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_UNLOCK = 0x09, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_AUTO_LOCK = 0x0A, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_LOCK = 0x0B, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_UNLOCK = 0x0C, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_LOCK = 0x0D, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_UNLOCK = 0x0E, +} EmberAfDoorLockOperationEventCode; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_MASTER_CODE_CHANGED = 0x01, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_ADDED = 0x02, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_DELETED = 0x03, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_CHANGED = 0x04, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_ADDED = 0x05, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_DELETED = 0x06, +} EmberAfDoorLockProgrammingEventCode; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_NETWORK_SECURITY = 0x00, + EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_APS_SECURITY = 0x01, +} EmberAfDoorLockSecurityLevel; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_SUCCESS = 0x00, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_GENERAL_FAILURE = 0x01, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_MEMORY_FULL = 0x02, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_DUPLICATE_CODE_ERROR = 0x03, +} EmberAfDoorLockSetPinOrIdStatus; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_SILENT = 0x00, + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_LOW = 0x01, + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_HIGH = 0x02, +} EmberAfDoorLockSoundVolume; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_STATE_NOT_FULLY_LOCKED = 0x00, + EMBER_ZCL_DOOR_LOCK_STATE_LOCKED = 0x01, + EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED = 0x02, +} EmberAfDoorLockState; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_BOLT = 0x00, + EMBER_ZCL_DOOR_LOCK_TYPE_MAGNETIC = 0x01, + EMBER_ZCL_DOOR_LOCK_TYPE_MORTISE = 0x02, + EMBER_ZCL_DOOR_LOCK_TYPE_RIM = 0x03, + EMBER_ZCL_DOOR_LOCK_TYPE_LATCH_BOLT = 0x04, + EMBER_ZCL_DOOR_LOCK_TYPE_CYLINDRICAL = 0x05, + EMBER_ZCL_DOOR_LOCK_TYPE_TUBULAR = 0x06, + EMBER_ZCL_DOOR_LOCK_TYPE_INTERCONNECTED = 0x07, + EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_LATCH = 0x08, + EMBER_ZCL_DOOR_LOCK_TYPE_OTHER = 0x09, +} EmberAfDoorLockType; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_USER_STATUS_AVAILABLE = 0x00, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_ENABLED = 0x01, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_DISABLED = 0x03, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_NOT_SUPPORTED = 0xFF, +} EmberAfDoorLockUserStatus; + +typedef enum { + EMBER_ZCL_DOOR_LOCK_USER_TYPE_UNRESTRICTED = 0x00, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_ONE_TIME_USER = 0x01, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_USER_WITH_SCHEDULE = 0x02, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_MASTER_USER = 0x03, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_NOT_SUPPORTED = 0xFF, +} EmberAfDoorLockUserType; + +typedef enum { + EMBER_ZCL_DOOR_STATE_OPEN = 0x00, + EMBER_ZCL_DOOR_STATE_CLOSED = 0x01, + EMBER_ZCL_DOOR_STATE_ERROR_JAMMED = 0x02, + EMBER_ZCL_DOOR_STATE_ERROR_FORCED_OPEN = 0x03, + EMBER_ZCL_DOOR_STATE_ERROR_UNSPECIFIED = 0x04, +} EmberAfDoorState; + +typedef enum { + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L1 = 0x10, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L1 = 0x11, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L2 = 0x12, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L2 = 0x13, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L3 = 0x14, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L3 = 0x15, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L1 = 0x16, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L2 = 0x17, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L3 = 0x18, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L1 = 0x19, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L1 = 0x1A, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L2 = 0x1B, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L2 = 0x1C, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L3 = 0x1D, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L3 = 0x1E, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_GROUND_FAULT = 0x1F, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_ELECTRIC_TAMPER_DETECT = 0x20, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_INCORRECT_POLARITY = 0x21, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_CURRENT_NO_VOLTAGE = 0x22, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_UNDER_VOLTAGE = 0x23, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_VOLTAGE = 0x24, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_NORMAL_VOLTAGE = 0x25, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_BELOW_THRESHOLD = 0x26, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_ABOVE_THRESHOLD = 0x27, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_REMOVED = 0x28, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_CLOSED = 0x29, +} EmberAfElectricityAlarmGroups; + +typedef enum { + EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, + EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, + EMBER_ZCL_ENHANCED_COLOR_MODE_COLOR_TEMPERATURE = 0x02, + EMBER_ZCL_ENHANCED_COLOR_MODE_ENHANCED_CURRENT_HUE_AND_CURRENT_SATURATION = 0x03, +} EmberAfEnhancedColorMode; + +typedef enum { + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LIST = 0x00, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_EVENT_GROUP = 0x01, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LOG_TYPE = 0x02, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_CONFIGURATION_MATCH = 0x03, +} EmberAfEventConfigurationControl; + +typedef enum { + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_DO_NOT_LOG = 0x00, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_TAMPER = 0x01, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_FAULT = 0x02, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_GENERAL_EVENT = 0x03, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_SECURITY_EVENT = 0x04, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_NETWORK_EVENT = 0x05, +} EmberAfEventConfigurationLogAction; + +typedef enum { + EMBER_ZCL_EVENT_CONTROL_RETRIEVE_MINIMAL_INFORMATION = 0x00, + EMBER_ZCL_EVENT_CONTROL_RETRIEVE_FULL_INFORMATION = 0x10, +} EmberAfEventControl; + +typedef enum { + EMBER_ZCL_EVENT_ID_METER_COVER_REMOVED = 0x00, + EMBER_ZCL_EVENT_ID_METER_COVER_CLOSED = 0x01, + EMBER_ZCL_EVENT_ID_STRONG_MAGNETIC_FIELD = 0x02, + EMBER_ZCL_EVENT_ID_NO_STRONG_MAGNETIC_FIELD = 0x03, + EMBER_ZCL_EVENT_ID_BATTERY_FAILURE = 0x04, + EMBER_ZCL_EVENT_ID_LOW_BATTERY = 0x05, + EMBER_ZCL_EVENT_ID_PROGRAM_MEMORY_ERROR = 0x06, + EMBER_ZCL_EVENT_ID_RAM_ERROR = 0x07, + EMBER_ZCL_EVENT_ID_NV_MEMORY_ERROR = 0x08, + EMBER_ZCL_EVENT_ID_MEASUREMENT_SYSTEM_ERROR = 0x09, + EMBER_ZCL_EVENT_ID_WATCHDOG_ERROR = 0x0A, + EMBER_ZCL_EVENT_ID_SUPPLY_DISCONNECT_FAILURE = 0x0B, + EMBER_ZCL_EVENT_ID_SUPPLY_CONNECT_FAILURE = 0x0C, + EMBER_ZCL_EVENT_ID_MEASURMENT_SOFTWARE_CHANGED = 0x0D, + EMBER_ZCL_EVENT_ID_DST_ENABLED = 0x0E, + EMBER_ZCL_EVENT_ID_DST_DISABLED = 0x0F, + EMBER_ZCL_EVENT_ID_CLOCK_ADJ_BACKWARD = 0x10, + EMBER_ZCL_EVENT_ID_CLOCK_ADJ_FORWARD = 0x11, + EMBER_ZCL_EVENT_ID_CLOCK_INVALID = 0x12, + EMBER_ZCL_EVENT_ID_COMMS_ERROR_HAN = 0x13, + EMBER_ZCL_EVENT_ID_COMMS_OK_HAN = 0x14, + EMBER_ZCL_EVENT_ID_FRAUD_ATTEMPT = 0x15, + EMBER_ZCL_EVENT_ID_POWER_LOSS = 0x16, + EMBER_ZCL_EVENT_ID_INCORRECT_PROTOCOL = 0x17, + EMBER_ZCL_EVENT_ID_UNUSUAL_HAN_TRAFFIC = 0x18, + EMBER_ZCL_EVENT_ID_UNEXPECTED_CLOCK_CHANGE = 0x19, + EMBER_ZCL_EVENT_ID_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x1A, + EMBER_ZCL_EVENT_ID_ERROR_REG_CLEAR = 0x1B, + EMBER_ZCL_EVENT_ID_ALARM_REG_CLEAR = 0x1C, + EMBER_ZCL_EVENT_ID_UNEXPECTED_HW_RESET = 0x1D, + EMBER_ZCL_EVENT_ID_UNEXPECTED_PROGRAM_EXECUTION = 0x1E, + EMBER_ZCL_EVENT_ID_EVENT_LOG_CLEARED = 0x1F, + EMBER_ZCL_EVENT_ID_MANUAL_DISCONNECT = 0x20, + EMBER_ZCL_EVENT_ID_MANUAL_CONNECT = 0x21, + EMBER_ZCL_EVENT_ID_REMOTE_DISCONNECTION = 0x22, + EMBER_ZCL_EVENT_ID_LOCAL_DISCONNECTION = 0x23, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_EXCEEDED = 0x24, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_OK = 0x25, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_CHANGED = 0x26, + EMBER_ZCL_EVENT_ID_MAXIMUM_DEMAND_EXCEEDED = 0x27, + EMBER_ZCL_EVENT_ID_PROFILE_CLEARED = 0x28, + EMBER_ZCL_EVENT_ID_FIRMWARE_READY_FOR_ACTIVATION = 0x29, + EMBER_ZCL_EVENT_ID_FIRMWARE_ACTIVATED = 0x2A, + EMBER_ZCL_EVENT_ID_PATCH_FAILURE = 0x2B, + EMBER_ZCL_EVENT_ID_TOU_TARIFF_ACTIVATION = 0x2C, + EMBER_ZCL_EVENT_ID_8X8_TARIFFACTIVATED = 0x2D, + EMBER_ZCL_EVENT_ID_SINGLE_TARIFF_RATE_ACTIVATED = 0x2E, + EMBER_ZCL_EVENT_ID_ASYNCHRONOUS_BILLING_OCCURRED = 0x2F, + EMBER_ZCL_EVENT_ID_SYNCHRONOUS_BILLING_OCCURRED = 0x30, + EMBER_ZCL_EVENT_ID_INCORRECT_POLARITY = 0x80, + EMBER_ZCL_EVENT_ID_CURRENT_NO_VOLTAGE = 0x81, + EMBER_ZCL_EVENT_ID_UNDER_VOLTAGE = 0x82, + EMBER_ZCL_EVENT_ID_OVER_VOLTAGE = 0x83, + EMBER_ZCL_EVENT_ID_NORMAL_VOLTAGE = 0x84, + EMBER_ZCL_EVENT_ID_PF_BELOW_THRESHOLD = 0x85, + EMBER_ZCL_EVENT_ID_PF_ABOVE_THRESHOLD = 0x86, + EMBER_ZCL_EVENT_ID_TERMINAL_COVER_REMOVED = 0x87, + EMBER_ZCL_EVENT_ID_TERMINAL_COVER_CLOSED = 0x88, + EMBER_ZCL_EVENT_ID_REVERSE_FLOW = 0xA0, + EMBER_ZCL_EVENT_ID_TILT_TAMPER = 0xA1, + EMBER_ZCL_EVENT_ID_BATTERY_COVER_REMOVED = 0xA2, + EMBER_ZCL_EVENT_ID_BATTERY_COVER_CLOSED = 0xA3, + EMBER_ZCL_EVENT_ID_EXCESS_FLOW = 0xA4, + EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_IN_USE = 0xC0, + EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_EXHAUSTED = 0xC1, + EMBER_ZCL_EVENT_ID_ZERO_CREDIT_EC_NOT_SELECTED = 0xC2, + EMBER_ZCL_EVENT_ID_SUPPLY_ON = 0xC3, + EMBER_ZCL_EVENT_ID_SUPPLY_OFF_AARMED = 0xC4, + EMBER_ZCL_EVENT_ID_SUPPLY_OFF = 0xC5, + EMBER_ZCL_EVENT_ID_DISCOUNT_APPLIED = 0xC6, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_A = 0xE0, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_B = 0xE1, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_C = 0xE2, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_D = 0xE3, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_E = 0xE4, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_F = 0xE5, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_G = 0xE6, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_H = 0xE7, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_I = 0xE8, +} EmberAfEventId; + +typedef enum { + EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_CYCLE = 0x01, + EMBER_ZCL_EVENT_IDENTIFICATION_TEMPERATURE_REACHED = 0x04, + EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_COOKING = 0x05, + EMBER_ZCL_EVENT_IDENTIFICATION_SWITCHING_OFF = 0x06, + EMBER_ZCL_EVENT_IDENTIFICATION_WRONG_DATA = 0x07, +} EmberAfEventIdentification; + +typedef enum { + EMBER_ZCL_EVENT_LOG_ID_ALL_LOGS = 0x00, + EMBER_ZCL_EVENT_LOG_ID_TAMPER_LOG = 0x01, + EMBER_ZCL_EVENT_LOG_ID_FAULT_LOG = 0x02, + EMBER_ZCL_EVENT_LOG_ID_GENERAL_EVENT_LOG = 0x03, + EMBER_ZCL_EVENT_LOG_ID_SECURITY_EVENT_LOG = 0x04, + EMBER_ZCL_EVENT_LOG_ID_NETWORK_EVENT_LOG = 0x05, + EMBER_ZCL_EVENT_LOG_ID_GBCS_GENERAL_EVENT_LOG = 0x06, + EMBER_ZCL_EVENT_LOG_ID_GBCS_SECURITY_EVENT_LOG = 0x07, +} EmberAfEventLogId; + +typedef enum { + EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENTS_DO_NOT_CROSS_FRAME_BOUNDARY = 0x00, + EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENT_CROSSES_FRAME_BOUNDARY = 0x01, +} EmberAfEventLogPayloadControl; + +typedef enum { + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASUREMENT_SYSTEM_ERROR = 0x70, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WATCHDOG_ERROR = 0x71, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_DISCONNECT_FAILURE = 0x72, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_CONNECT_FAILURE = 0x73, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASURMENT_SOFTWARE_CHANGED = 0x74, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_ENABLED = 0x75, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_DISABLED = 0x76, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_BACKWARD = 0x77, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_FORWARD = 0x78, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_INVALID = 0x79, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_ERROR_HAN = 0x7A, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_OK_H_AN = 0x7B, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_FRAUD_ATTEMPT = 0x7C, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_POWER_LOSS = 0x7D, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNUSUAL_HAN_TRAFFIC = 0x7E, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_CLOCK_CHANGE = 0x7F, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ERROR_REG_CLEAR = 0x81, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ALARM_REG_CLEAR = 0x82, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_HW_RESET = 0x83, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_PROGRAM_EXECUTION = 0x84, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EVENT_LOG_CLEARED = 0x85, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_EXCEEDED = 0x86, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_OK = 0x87, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_CHANGED = 0x88, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MAXIMUM_DEMAND_EXCEEDED = 0x89, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_PROFILE_CLEARED = 0x8A, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SAMPLING_BUFFERCLEARED = 0x8B, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_BATTERY_WARNING = 0x8C, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WRONG_SIGNATURE = 0x8D, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_NO_SIGNATURE = 0x8E, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_START = 0x90, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_END = 0x91, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_REPORTING_INTERVAL_CHANGED = 0x92, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, +} EmberAfExtendedGenericAlarmGroups; + +typedef enum { + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_REFER_TO_NUMBER_OF_PRICE_TIERS_FIELD = 0x00, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS16 = 0x01, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS17 = 0x02, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS18 = 0x03, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS19 = 0x04, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS20 = 0x05, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS21 = 0x06, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS22 = 0x07, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS23 = 0x08, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS24 = 0x09, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS25 = 0x0A, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS26 = 0x0B, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS27 = 0x0C, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS28 = 0x0D, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS29 = 0x0E, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS30 = 0x0F, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS31 = 0x10, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS32 = 0x11, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS33 = 0x12, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS34 = 0x13, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS35 = 0x14, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS36 = 0x15, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS37 = 0x16, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS38 = 0x17, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS39 = 0x18, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS40 = 0x19, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS41 = 0x1A, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS42 = 0x1B, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS43 = 0x1C, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS44 = 0x1D, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS45 = 0x1E, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS46 = 0x1F, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS47 = 0x20, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS48 = 0x21, +} EmberAfExtendedNumberOfPriceTiers; + +typedef enum { + EMBER_ZCL_EXTENDED_PRICE_TIER_REFER_TO_PRICE_TIER_FIELD = 0x00, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER16_PRICE_LABEL = 0x01, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER17_PRICE_LABEL = 0x02, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER18_PRICE_LABEL = 0x03, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER19_PRICE_LABEL = 0x04, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER20_PRICE_LABEL = 0x05, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER21_PRICE_LABEL = 0x06, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER22_PRICE_LABEL = 0x07, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER23_PRICE_LABEL = 0x08, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER24_PRICE_LABEL = 0x09, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER25_PRICE_LABEL = 0x0A, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER26_PRICE_LABEL = 0x0B, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER27_PRICE_LABEL = 0x0C, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER28_PRICE_LABEL = 0x0D, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER29_PRICE_LABEL = 0x0E, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER30_PRICE_LABEL = 0x0F, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER31_PRICE_LABEL = 0x10, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER32_PRICE_LABEL = 0x11, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER33_PRICE_LABEL = 0x12, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER34_PRICE_LABEL = 0x13, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER35_PRICE_LABEL = 0x14, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER36_PRICE_LABEL = 0x15, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER37_PRICE_LABEL = 0x16, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER38_PRICE_LABEL = 0x17, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER39_PRICE_LABEL = 0x18, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER40_PRICE_LABEL = 0x19, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER41_PRICE_LABEL = 0x1A, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER42_PRICE_LABEL = 0x1B, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER43_PRICE_LABEL = 0x1C, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER44_PRICE_LABEL = 0x1D, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER45_PRICE_LABEL = 0x1E, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER46_PRICE_LABEL = 0x1F, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER47_PRICE_LABEL = 0x20, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER48_PRICE_LABEL = 0x21, +} EmberAfExtendedPriceTier; + +typedef enum { + EMBER_ZCL_EXTENDED_REGISTER_TIER_REFER_TO_REGISTER_TIER_FIELD = 0x00, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE = 0x10, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE = 0x11, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE = 0x12, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE = 0x13, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE = 0x14, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE = 0x15, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE = 0x16, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE = 0x17, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE = 0x18, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE = 0x19, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE = 0x1A, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE = 0x1B, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE = 0x1C, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE = 0x1D, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE = 0x1E, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE = 0x1F, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE = 0x20, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE = 0x21, +} EmberAfExtendedRegisterTier; + +typedef enum { + EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_SERVER = 0x00, + EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_CLIENT = 0x01, +} EmberAfEzModeCommissioningClusterType; + +typedef enum { + EMBER_ZCL_FAN_MODE_OFF = 0x00, + EMBER_ZCL_FAN_MODE_LOW = 0x01, + EMBER_ZCL_FAN_MODE_MEDIUM = 0x02, + EMBER_ZCL_FAN_MODE_HIGH = 0x03, + EMBER_ZCL_FAN_MODE_ON = 0x04, + EMBER_ZCL_FAN_MODE_AUTO = 0x05, + EMBER_ZCL_FAN_MODE_SMART = 0x06, +} EmberAfFanMode; + +typedef enum { + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH = 0x00, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH = 0x01, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH_AUTO = 0x02, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH_AUTO = 0x03, + EMBER_ZCL_FAN_MODE_SEQUENCE_ON_AUTO = 0x04, +} EmberAfFanModeSequence; + +typedef enum { + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER = 0x60, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_REMOVED = 0x61, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_CLOSED = 0x62, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_EXCESS_FLOW = 0x63, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER_ENDED = 0x64, +} EmberAfGasSpecificAlarmGroups; + +typedef enum { + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE = 0x01, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE = 0x02, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE = 0x03, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE = 0x04, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE = 0x05, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE = 0x06, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE = 0x07, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE = 0x08, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE = 0x09, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE = 0x0A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE = 0x0B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE = 0x0C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE = 0x0D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE = 0x0E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE = 0x0F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE = 0x10, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE = 0x11, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE = 0x12, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE = 0x13, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE = 0x14, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE = 0x15, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE = 0x16, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE = 0x17, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE = 0x18, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE = 0x19, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE = 0x1A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE = 0x1B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE = 0x1C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE = 0x1D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE = 0x1E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE = 0x1F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE = 0x20, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE = 0x21, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE = 0x22, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE = 0x23, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE = 0x24, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE = 0x25, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE = 0x26, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE = 0x27, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE = 0x28, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE = 0x29, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE = 0x2A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE = 0x2B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE = 0x2C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE = 0x2D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE = 0x2E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE = 0x2F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE = 0x30, +} EmberAfGenerationTier; + +typedef enum { + EMBER_ZCL_GENERIC_ALARM_GROUPS_CHECK_METER = 0x00, + EMBER_ZCL_GENERIC_ALARM_GROUPS_LOW_BATTERY = 0x01, + EMBER_ZCL_GENERIC_ALARM_GROUPS_TAMPER_DETECT = 0x02, + EMBER_ZCL_GENERIC_ALARM_GROUPS_LEAK_DETECT = 0x05, + EMBER_ZCL_GENERIC_ALARM_GROUPS_SERVICE_DISCONNECT = 0x06, + EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_REMOVED = 0x08, + EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_CLOSED = 0x09, + EMBER_ZCL_GENERIC_ALARM_GROUPS_STRONG_MAGNETIC_FIELD = 0x0A, + EMBER_ZCL_GENERIC_ALARM_GROUPS_NO_STRONG_MAGNETIC_FIELD = 0x0B, + EMBER_ZCL_GENERIC_ALARM_GROUPS_BATTERY_FAILURE = 0x0C, + EMBER_ZCL_GENERIC_ALARM_GROUPS_PROGRAM_MEMORY_ERROR = 0x0D, + EMBER_ZCL_GENERIC_ALARM_GROUPS_R_A_M_ERROR = 0x0E, + EMBER_ZCL_GENERIC_ALARM_GROUPS_N_V_MEMORY_ERROR = 0x0F, +} EmberAfGenericAlarmGroups; + +typedef enum { + EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_FAILURE = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_QUALITY = 0x04, +} EmberAfGenericAlarmGroupsElectricity; + +typedef enum { + EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_LOW_PRESSURE = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_REVERSE_FLOW = 0x07, +} EmberAfGenericAlarmGroupsGas; + +typedef enum { + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_TEMPERATURE_SENSOR = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_BURST_DETECT = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_FLOW_SENSOR = 0x07, +} EmberAfGenericAlarmGroupsHeatCooling; + +typedef enum { + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_PIPE_EMPTY = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_LOW_PRESSURE = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_REVERSE_FLOW = 0x07, +} EmberAfGenericAlarmGroupsWater; + +typedef enum { + EMBER_ZCL_GENERIC_DEVICE_CLASS_LIGHTING = 0x00, +} EmberAfGenericDeviceClass; + +typedef enum { + EMBER_ZCL_GENERIC_DEVICE_TYPE_INCANDESCENT = 0x00, + EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_HALOGEN = 0x01, + EMBER_ZCL_GENERIC_DEVICE_TYPE_HALOGEN_BULB = 0x02, + EMBER_ZCL_GENERIC_DEVICE_TYPE_CFL = 0x03, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LINEAR_FLOURESCENT = 0x04, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_BULB = 0x05, + EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_LED = 0x06, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_STRIP = 0x07, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_TUBE = 0x08, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_INDOOR_FIXTURE = 0x09, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_OUTDOOR_FIXTURE = 0x0A, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PENDANT_FIXTURE = 0x0B, + EMBER_ZCL_GENERIC_DEVICE_TYPE_FLOOR_STANDING_FIXTURE = 0x0C, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_CONTROLLER = 0xE0, + EMBER_ZCL_GENERIC_DEVICE_TYPE_WALL_SWITCH = 0xE1, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PORTABLE_REMOTE_CONTROLLER = 0xE2, + EMBER_ZCL_GENERIC_DEVICE_TYPE_MOTION_OR_LIGHT_SENSOR = 0xE3, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_ACTUATOR = 0xF0, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PLUGIN_UNIT = 0xF1, + EMBER_ZCL_GENERIC_DEVICE_TYPE_RETROFIT_ACTUATOR = 0xF2, + EMBER_ZCL_GENERIC_DEVICE_TYPE_UNSPECIFIED = 0xFF, +} EmberAfGenericDeviceType; + +typedef enum { + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_BURST_DETECT = 0x30, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_LOW = 0x31, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_HIGH = 0x32, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_REVERSE_FLOW = 0x35, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_AIR_DETECT = 0x36, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PIPE_EMPTY = 0x37, +} EmberAfGenericFlowPressureAlarmGroups; + +typedef enum { + EMBER_ZCL_GP_DEVICE_ID_GP_SIMPLE_GENERICE_TWO_STATE_SWITCH = 0x00, + EMBER_ZCL_GP_DEVICE_ID_GP_ON_OFF_SWITCH = 0x08, + EMBER_ZCL_GP_DEVICE_ID_GP_LEVEL_CONTROL_SWITCH = 0x10, + EMBER_ZCL_GP_DEVICE_ID_GP_INDOOR_ENVIRONMENT_SNESOR = 0x18, +} EmberAfGpDeviceId; + +typedef enum { + EMBER_ZCL_GP_GPDF_IDENTIFY = 0x00, + EMBER_ZCL_GP_GPDF_MATCH_ONLY_ON_GPD_ADDRESS = 0x02, + EMBER_ZCL_GP_GPDF_RECALL_SCENE0 = 0x10, + EMBER_ZCL_GP_GPDF_RECALL_SCENE1 = 0x11, + EMBER_ZCL_GP_GPDF_RECALL_SCENE2 = 0x12, + EMBER_ZCL_GP_GPDF_RECALL_SCENE3 = 0x13, + EMBER_ZCL_GP_GPDF_RECALL_SCENE4 = 0x14, + EMBER_ZCL_GP_GPDF_RECALL_SCENE5 = 0x15, + EMBER_ZCL_GP_GPDF_RECALL_SCENE6 = 0x16, + EMBER_ZCL_GP_GPDF_RECALL_SCENE7 = 0x17, + EMBER_ZCL_GP_GPDF_STORE_SCENE0 = 0x18, + EMBER_ZCL_GP_GPDF_STORE_SCENE1 = 0x19, + EMBER_ZCL_GP_GPDF_STORE_SCENE2 = 0x1A, + EMBER_ZCL_GP_GPDF_STORE_SCENE3 = 0x1B, + EMBER_ZCL_GP_GPDF_STORE_SCENE4 = 0x1C, + EMBER_ZCL_GP_GPDF_STORE_SCENE5 = 0x1D, + EMBER_ZCL_GP_GPDF_STORE_SCENE6 = 0x1E, + EMBER_ZCL_GP_GPDF_STORE_SCENE7 = 0x1F, + EMBER_ZCL_GP_GPDF_OFF = 0x20, + EMBER_ZCL_GP_GPDF_ON = 0x21, + EMBER_ZCL_GP_GPDF_TOGGLE = 0x22, + EMBER_ZCL_GP_GPDF_RELEASE = 0x23, + EMBER_ZCL_GP_GPDF_MOVE_UP = 0x30, + EMBER_ZCL_GP_GPDF_MOVE_DOWN = 0x31, + EMBER_ZCL_GP_GPDF_STEP_UP = 0x32, + EMBER_ZCL_GP_GPDF_STEP_DOWN = 0x33, + EMBER_ZCL_GP_GPDF_LEVEL_CONTROL_STOP = 0x34, + EMBER_ZCL_GP_GPDF_MOVE_UP_WITH_ON_OFF = 0x35, + EMBER_ZCL_GP_GPDF_MOVE_DOWN_WITH_ON_OFF = 0x36, + EMBER_ZCL_GP_GPDF_STEP_UP_WITH_ON_OFF = 0x37, + EMBER_ZCL_GP_GPDF_STEP_DOWN_WITH_ON_OFF = 0x38, + EMBER_ZCL_GP_GPDF_MOVE_HUE_STOP = 0x40, + EMBER_ZCL_GP_GPDF_MOVE_HUE_UP = 0x41, + EMBER_ZCL_GP_GPDF_MOVE_HUE_DOWN = 0x42, + EMBER_ZCL_GP_GPDF_STEP_HUE_UP = 0x43, + EMBER_ZCL_GP_GPDF_STEP_HUE_DOWN = 0x44, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_STOP = 0x45, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_UP = 0x46, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_DOWN = 0x47, + EMBER_ZCL_GP_GPDF_STEP_SATURATION_UP = 0x48, + EMBER_ZCL_GP_GPDF_STEP_SATURATION_DOWN = 0x49, + EMBER_ZCL_GP_GPDF_MOVE_COLOR = 0x4A, + EMBER_ZCL_GP_GPDF_STEP_COLOR = 0x4B, + EMBER_ZCL_GP_GPDF_LOCK_DOOR = 0x50, + EMBER_ZCL_GP_GPDF_UNLOCK_DOOR = 0x51, + EMBER_ZCL_GP_GPDF_PRESS1_OF1 = 0x60, + EMBER_ZCL_GP_GPDF_RELEASE1_OF1 = 0x61, + EMBER_ZCL_GP_GPDF_PRESS1_OF2 = 0x62, + EMBER_ZCL_GP_GPDF_RELEASE1_OF2 = 0x63, + EMBER_ZCL_GP_GPDF_PRESS2_OF2 = 0x64, + EMBER_ZCL_GP_GPDF_RELEASE2_OF2 = 0x65, + EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF1 = 0x66, + EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF2 = 0x67, + EMBER_ZCL_GP_GPDF_SHORT_PRESS2_OF2 = 0x68, + EMBER_ZCL_GP_GPDF_8BITS_VECTOR_PRESS = 0x69, + EMBER_ZCL_GP_GPDF_8BITS_VECTOR_RELEASE = 0x6A, + EMBER_ZCL_GP_GPDF_ATTRIBUTE_REPORTING = 0xA0, + EMBER_ZCL_GP_GPDF_MFR_SP_ATTR_RPTG = 0xA1, + EMBER_ZCL_GP_GPDF_MULTI_CLUSTER_RPTG = 0xA2, + EMBER_ZCL_GP_GPDF_MFR_SP_MULTI_CLUSTER_RPTG = 0xA3, + EMBER_ZCL_GP_GPDF_REQUEST_ATTRIBUTE = 0xA4, + EMBER_ZCL_GP_GPDF_READ_ATTR_RESPONSE = 0xA5, + EMBER_ZCL_GP_GPDF_ZCL_TUNNELING_WITH_PAYLOAD = 0xA6, + EMBER_ZCL_GP_GPDF_COMPACT_ATTRIBUTE_REPORTING = 0xA8, + EMBER_ZCL_GP_GPDF_ANY_GPD_SENSOR_CMD = 0xAF, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD0 = 0xB0, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD1 = 0xB1, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD2 = 0xB2, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD3 = 0xB3, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD4 = 0xB4, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD5 = 0xB5, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD6 = 0xB6, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD7 = 0xB7, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD8 = 0xB8, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD9 = 0xB9, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_A = 0xBA, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_B = 0xBB, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_C = 0xBC, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_D = 0xBD, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_E = 0xBE, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_F = 0xBF, + EMBER_ZCL_GP_GPDF_COMMISSIONING = 0xE0, + EMBER_ZCL_GP_GPDF_DECOMMISSIONING = 0xE1, + EMBER_ZCL_GP_GPDF_SUCCESS = 0xE2, + EMBER_ZCL_GP_GPDF_CHANNEL_REQUEST = 0xE3, + EMBER_ZCL_GP_GPDF_APPLICATION_DESCRIPTION = 0xE4, + EMBER_ZCL_GP_GPDF_COMMISSIONING_REPLY = 0xF0, + EMBER_ZCL_GP_GPDF_WRITE_ATTRIBUTES = 0xF1, + EMBER_ZCL_GP_GPDF_READ_ATTRIBUTES = 0xF2, + EMBER_ZCL_GP_GPDF_CHANNEL_CONFIGURATION = 0xF3, + EMBER_ZCL_GP_GPDF_ZCL_TUNNELING = 0xF6, +} EmberAfGpGpdf; + +typedef enum { + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_NO_ACTION = 0x00, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_EXTEND_SINK_TABLE_ENTRY = 0x01, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REPLACE_SINK_TABLE_ENTRY = 0x02, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_A_PAIRING = 0x03, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_GPD = 0x04, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_APPLICATION_DESCRIPTION = 0x05, +} EmberAfGpPairingConfigurationAction; + +typedef enum { + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING = 0x00, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_I_D = 0x08, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMMISSIONED = 0x10, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING_LIGHTWEIGHT = 0x18, +} EmberAfGpPairingConfigurationOptionCommunicationMode; + +typedef enum { + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_FULL_UNICAST_FORWARDING = 0x00, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_ID = 0x01, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMM_UNIT = 0x10, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_UNICAST_FORWARDING_BY_PROX_SUPPORT = 0x11, +} EmberAfGpPairingOptionsCommunicationMode; + +typedef enum { + EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_GPD_ID = 0x00, + EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_INDEX = 0x01, +} EmberAfGpProxyTableRequestOptionsRequestType; + +typedef enum { + EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +} EmberAfGpProxyTableResponseStatus; + +typedef enum { + EMBER_ZCL_GP_SECURITY_KEY_TYPE_NONE = 0x00, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_ZIGBEE_NETWORK_KEY = 0x01, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_GPD_GROUP_KEY = 0x02, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_NETWORK_DERIVED_GROUP_KEY = 0x03, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_INDIVIDIGUAL_GPD_KEY = 0x04, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_DERIVED_INDIVIDUAL_GPD_KEY = 0x07, +} EmberAfGpSecurityKeyType; + +typedef enum { + EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_GPD_ID = 0x00, + EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_INDEX = 0x01, +} EmberAfGpSinkTableRequestOptions; + +typedef enum { + EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +} EmberAfGpSinkTableResponseStatus; + +typedef enum { + EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +} EmberAfGpTranslationTableResponseStatus; + +typedef enum { + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_ADD_TRANSLATION_TABLE_ENTRY = 0x00, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REPLACE_TRANSLATION_TABLE_ENTRY = 0x08, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REMOVE_TRANSLATION_TABLE_ENTRY = 0x10, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_RESERVED = 0x18, +} EmberAfGpTranslationTableUpdateAction; + +typedef enum { + EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, + EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, +} EmberAfHeatAndCoolingSpecificAlarmGroups; + +typedef enum { + EMBER_ZCL_HUE_DIRECTION_SHORTEST_DISTANCE = 0x00, + EMBER_ZCL_HUE_DIRECTION_LONGEST_DISTANCE = 0x01, + EMBER_ZCL_HUE_DIRECTION_UP = 0x02, + EMBER_ZCL_HUE_DIRECTION_DOWN = 0x03, +} EmberAfHueDirection; + +typedef enum { + EMBER_ZCL_HUE_MOVE_MODE_STOP = 0x00, + EMBER_ZCL_HUE_MOVE_MODE_UP = 0x01, + EMBER_ZCL_HUE_MOVE_MODE_DOWN = 0x03, +} EmberAfHueMoveMode; + +typedef enum { + EMBER_ZCL_HUE_STEP_MODE_UP = 0x01, + EMBER_ZCL_HUE_STEP_MODE_DOWN = 0x03, +} EmberAfHueStepMode; + +typedef enum { + EMBER_ZCL_IAS_ACE_ALARM_STATUS_NO_ALARM = 0x00, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_BURGLAR = 0x01, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE = 0x02, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY = 0x03, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_POLICE_PANIC = 0x04, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE_PANIC = 0x05, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY_PANIC = 0x06, +} EmberAfIasAceAlarmStatus; + +typedef enum { + EMBER_ZCL_IAS_ACE_ARM_MODE_DISARM = 0x00, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_DAY_HOME_ZONES_ONLY = 0x01, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_NIGHT_SLEEP_ZONES_ONLY = 0x02, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_ALL_ZONES = 0x03, +} EmberAfIasAceArmMode; + +typedef enum { + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_DISARMED = 0x00, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_DAY_HOME_ZONES_ARMED = 0x01, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_NIGHT_SLEEP_ZONES_ARMED = 0x02, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_ARMED = 0x03, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_INVALID_ARM_DISARM_CODE = 0x04, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_NOT_READY_TO_ARM = 0x05, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALREADY_DISARMED = 0x06, +} EmberAfIasAceArmNotification; + +typedef enum { + EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_MUTE = 0x00, + EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_DEFAULT_SOUND = 0x01, +} EmberAfIasAceAudibleNotification; + +typedef enum { + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_BYPASSED = 0x00, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_NOT_BYPASSED = 0x01, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_NOT_ALLOWED = 0x02, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ZONE_ID = 0x03, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_UNKNOWN_ZONE_ID = 0x04, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ARM_DISARM_CODE = 0x05, +} EmberAfIasAceBypassResult; + +typedef enum { + EMBER_ZCL_IAS_ACE_PANEL_STATUS_PANEL_DISARMED = 0x00, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_STAY = 0x01, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_NIGHT = 0x02, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_AWAY = 0x03, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_EXIT_DELAY = 0x04, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ENTRY_DELAY = 0x05, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_NOT_READY_TO_ARM = 0x06, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_IN_ALARM = 0x07, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_STAY = 0x08, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_NIGHT = 0x09, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_AWAY = 0x0A, +} EmberAfIasAcePanelStatus; + +typedef enum { + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_SUCCESS = 0x00, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NOT_SUPPORTED = 0x01, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NO_ENROLL_PERMIT = 0x02, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_TOO_MANY_ZONES = 0x03, +} EmberAfIasEnrollResponseCode; + +typedef enum { + EMBER_ZCL_IAS_ZONE_STATE_NOT_ENROLLED = 0x00, + EMBER_ZCL_IAS_ZONE_STATE_ENROLLED = 0x01, +} EmberAfIasZoneState; + +typedef enum { + EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_CIE = 0x0000, + EMBER_ZCL_IAS_ZONE_TYPE_MOTION_SENSOR = 0x000D, + EMBER_ZCL_IAS_ZONE_TYPE_CONTACT_SWITCH = 0x0015, + EMBER_ZCL_IAS_ZONE_TYPE_FIRE_SENSOR = 0x0028, + EMBER_ZCL_IAS_ZONE_TYPE_WATER_SENSOR = 0x002A, + EMBER_ZCL_IAS_ZONE_TYPE_GAS_SENSOR = 0x002B, + EMBER_ZCL_IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x002C, + EMBER_ZCL_IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x002D, + EMBER_ZCL_IAS_ZONE_TYPE_REMOTE_CONTROL = 0x010F, + EMBER_ZCL_IAS_ZONE_TYPE_KEY_FOB = 0x0115, + EMBER_ZCL_IAS_ZONE_TYPE_KEYPAD = 0x021D, + EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE = 0x0225, + EMBER_ZCL_IAS_ZONE_TYPE_GLASS_BREAK_SENSOR = 0x0226, + EMBER_ZCL_IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR = 0x0227, + EMBER_ZCL_IAS_ZONE_TYPE_SECURITY_REPEATER = 0x0229, + EMBER_ZCL_IAS_ZONE_TYPE_INVALID_ZONE_TYPE = 0xFFFF, +} EmberAfIasZoneType; + +typedef enum { + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK = 0x00, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE = 0x01, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY = 0x02, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE = 0x0B, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_FINISH_EFFECT = 0xFE, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_STOP_EFFECT = 0xFF, +} EmberAfIdentifyEffectIdentifier; + +typedef enum { + EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT = 0x00, +} EmberAfIdentifyEffectVariant; + +typedef enum { + EMBER_ZCL_KEY_INDEX_DEVELOPMENT = 0x00, + EMBER_ZCL_KEY_INDEX_MASTER = 0x04, + EMBER_ZCL_KEY_INDEX_CERTIFICATION = 0x0F, +} EmberAfKeyIndex; + +typedef enum { + EMBER_ZCL_KEYPAD_LOCKOUT_NO_LOCKOUT = 0x00, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_ONE_LOCKOUT = 0x01, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_TWO_LOCKOUT = 0x02, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_THREE_LOCKOUT = 0x03, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_FOUR_LOCKOUT = 0x04, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVELFIVE_LOCKOUT = 0x05, +} EmberAfKeypadLockout; + +typedef enum { + EMBER_ZCL_LEVEL_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, + EMBER_ZCL_LEVEL_CONTROL_OPTIONS_COUPLE_COLOR_TEMP_TO_LEVEL = 0x02, +} EmberAfLevelControlOptions; + +typedef enum { + EMBER_ZCL_LEVEL_STATUS_ON_TARGET = 0x00, + EMBER_ZCL_LEVEL_STATUS_BELOW_TARGET = 0x01, + EMBER_ZCL_LEVEL_STATUS_ABOVE_TARGET = 0x02, +} EmberAfLevelStatus; + +typedef enum { + EMBER_ZCL_LOCATION_METHOD_LATERATION = 0x00, + EMBER_ZCL_LOCATION_METHOD_SIGNPOSTING = 0x01, + EMBER_ZCL_LOCATION_METHOD_RF_FINGERPRINTING = 0x02, + EMBER_ZCL_LOCATION_METHOD_OUT_OF_BAND = 0x03, +} EmberAfLocationMethod; + +typedef enum { + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_A = 0xB0, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_B = 0xB1, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_C = 0xB2, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_D = 0xB3, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_E = 0xB4, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_F = 0xB5, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_G = 0xB6, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_H = 0xB7, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_I = 0xB8, +} EmberAfManufacturerSpecificAlarmGroups; + +typedef enum { + EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, + EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_CMOS = 0x01, +} EmberAfMeasurementLightSensorType; + +typedef enum { + EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_NOT_REQUIRED = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_REQUIRED = 0x80, +} EmberAfMessagingControlConfirmation; + +typedef enum { + EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_NOT_REQUIRED = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_REQUIRED = 0x20, +} EmberAfMessagingControlEnhancedConfirmation ; + +typedef enum { + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_LOW = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_MEDIUM = 0x04, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_HIGH = 0x08, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_CRITICAL = 0x0C, +} EmberAfMessagingControlImportance; + +typedef enum { + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL_AND_ANONYMOUS = 0x01, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_ANONYMOUS = 0x02, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_RESERVED = 0x03, +} EmberAfMessagingControlTransmission; + +typedef enum { + EMBER_ZCL_METER_DEVICE_TYPE_ELECTRIC_METER = 0x00, + EMBER_ZCL_METER_DEVICE_TYPE_GAS_METER = 0x01, + EMBER_ZCL_METER_DEVICE_TYPE_WATER_METER = 0x02, + EMBER_ZCL_METER_DEVICE_TYPE_THERMAL_METER = 0x03, + EMBER_ZCL_METER_DEVICE_TYPE_PRESSURE_METER = 0x04, + EMBER_ZCL_METER_DEVICE_TYPE_HEAT_METER = 0x05, + EMBER_ZCL_METER_DEVICE_TYPE_COOLING_METER = 0x06, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_GAS_METER = 0x80, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_WATER_METER = 0x81, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_THERMAL_METER = 0x82, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_PRESSURE_METER = 0x83, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_HEAT_METER = 0x84, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_COOLING_METER = 0x85, + EMBER_ZCL_METER_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, +} EmberAfMeterDeviceType; + +typedef enum { + EMBER_ZCL_METER_TYPE_ID_UTILITY_PRIMARY_METER = 0x0000, + EMBER_ZCL_METER_TYPE_ID_UTILITY_PRODUCTION_METER = 0x0001, + EMBER_ZCL_METER_TYPE_ID_UTILITY_SECONDARY_METER = 0x0002, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRIMARY_METER = 0x0100, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRODUCTION_METER = 0x0101, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_SECONDARY_METERS = 0x0102, + EMBER_ZCL_METER_TYPE_ID_GENERIC_METER = 0x0110, +} EmberAfMeterTypeId; + +typedef enum { + EMBER_ZCL_METERING_ALARM_CODE_CHECK_METER = 0x00, + EMBER_ZCL_METERING_ALARM_CODE_LOW_BATTERY = 0x01, + EMBER_ZCL_METERING_ALARM_CODE_TAMPER_DETECT = 0x02, + EMBER_ZCL_METERING_ALARM_CODE_POWER_FAILURE_PIPE_EMPTY_TEMPERATURE_SENSOR = 0x03, + EMBER_ZCL_METERING_ALARM_CODE_POWER_QUALITY_LOW_PRESSURE_BURST_DETECT = 0x04, + EMBER_ZCL_METERING_ALARM_CODE_LEAK_DETECT = 0x05, + EMBER_ZCL_METERING_ALARM_CODE_SERVICE_DISCONNECT = 0x06, + EMBER_ZCL_METERING_ALARM_CODE_REVERSE_FLOW_FLOW_SENSOR = 0x07, + EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_REMOVED = 0x08, + EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_CLOSED = 0x09, + EMBER_ZCL_METERING_ALARM_CODE_STRONG_MAGNETIC_FIELD = 0x0A, + EMBER_ZCL_METERING_ALARM_CODE_NO_STRONG_MAGNETIC_FIELD = 0x0B, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_FAILURE = 0x0C, + EMBER_ZCL_METERING_ALARM_CODE_PROGRAM_MEMORY_ERROR = 0x0D, + EMBER_ZCL_METERING_ALARM_CODE_R_A_M_ERROR = 0x0E, + EMBER_ZCL_METERING_ALARM_CODE_N_V_MEMORY_ERROR = 0x0F, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L1 = 0x10, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L1 = 0x11, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L2 = 0x12, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L2 = 0x13, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L3 = 0x14, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L3 = 0x15, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L1 = 0x16, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L2 = 0x17, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L3 = 0x18, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L1 = 0x19, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L1 = 0x1A, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L2 = 0x1B, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L2 = 0x1C, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L3 = 0x1D, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L3 = 0x1E, + EMBER_ZCL_METERING_ALARM_CODE_GROUND_FAULT = 0x1F, + EMBER_ZCL_METERING_ALARM_CODE_ELECTRIC_TAMPER_DETECT = 0x20, + EMBER_ZCL_METERING_ALARM_CODE_INCORRECT_POLARITY = 0x21, + EMBER_ZCL_METERING_ALARM_CODE_CURRENT_NO_VOLTAGE = 0x22, + EMBER_ZCL_METERING_ALARM_CODE_UNDER_VOLTAGE = 0x23, + EMBER_ZCL_METERING_ALARM_CODE_OVER_VOLTAGE = 0x24, + EMBER_ZCL_METERING_ALARM_CODE_NORMAL_VOLTAGE = 0x25, + EMBER_ZCL_METERING_ALARM_CODE_P_F_BELOW_THRESHOLD = 0x26, + EMBER_ZCL_METERING_ALARM_CODE_P_F_ABOVE_THRESHOLD = 0x27, + EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_REMOVED = 0x28, + EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_CLOSED = 0x29, + EMBER_ZCL_METERING_ALARM_CODE_BURST_DETECT = 0x30, + EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_LOW = 0x31, + EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_HIGH = 0x32, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_REVERSE_FLOW = 0x35, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_AIR_DETECT = 0x36, + EMBER_ZCL_METERING_ALARM_CODE_PIPE_EMPTY = 0x37, + EMBER_ZCL_METERING_ALARM_CODE_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, + EMBER_ZCL_METERING_ALARM_CODE_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, + EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER = 0x60, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_REMOVED = 0x61, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_CLOSED = 0x62, + EMBER_ZCL_METERING_ALARM_CODE_EXCESS_FLOW = 0x63, + EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER_ENDED = 0x64, + EMBER_ZCL_METERING_ALARM_CODE_MEASUREMENT_SYSTEM_ERROR = 0x70, + EMBER_ZCL_METERING_ALARM_CODE_WATCHDOG_ERROR = 0x71, + EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_DISCONNECT_FAILURE = 0x72, + EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_CONNECT_FAILURE = 0x73, + EMBER_ZCL_METERING_ALARM_CODE_MEASURMENT_SOFTWARE_CHANGED = 0x74, + EMBER_ZCL_METERING_ALARM_CODE_DST_ENABLED = 0x75, + EMBER_ZCL_METERING_ALARM_CODE_DST_DISABLED = 0x76, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_BACKWARD = 0x77, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_FORWARD = 0x78, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_INVALID = 0x79, + EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_ERROR_HAN = 0x7A, + EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_OK_H_AN = 0x7B, + EMBER_ZCL_METERING_ALARM_CODE_METER_FRAUD_ATTEMPT = 0x7C, + EMBER_ZCL_METERING_ALARM_CODE_POWER_LOSS = 0x7D, + EMBER_ZCL_METERING_ALARM_CODE_UNUSUAL_HAN_TRAFFIC = 0x7E, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_CLOCK_CHANGE = 0x7F, + EMBER_ZCL_METERING_ALARM_CODE_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, + EMBER_ZCL_METERING_ALARM_CODE_ERROR_REG_CLEAR = 0x81, + EMBER_ZCL_METERING_ALARM_CODE_ALARM_REG_CLEAR = 0x82, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_HW_RESET = 0x83, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_PROGRAM_EXECUTION = 0x84, + EMBER_ZCL_METERING_ALARM_CODE_EVENT_LOG_CLEARED = 0x85, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_EXCEEDED = 0x86, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_OK = 0x87, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_CHANGED = 0x88, + EMBER_ZCL_METERING_ALARM_CODE_MAXIMUM_DEMAND_EXCEEDED = 0x89, + EMBER_ZCL_METERING_ALARM_CODE_PROFILE_CLEARED = 0x8A, + EMBER_ZCL_METERING_ALARM_CODE_SAMPLING_BUFFERCLEARED = 0x8B, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_WARNING = 0x8C, + EMBER_ZCL_METERING_ALARM_CODE_WRONG_SIGNATURE = 0x8D, + EMBER_ZCL_METERING_ALARM_CODE_NO_SIGNATURE = 0x8E, + EMBER_ZCL_METERING_ALARM_CODE_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, + EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_START = 0x90, + EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_END = 0x91, + EMBER_ZCL_METERING_ALARM_CODE_METER_REPORTING_INTERVAL_CHANGED = 0x92, + EMBER_ZCL_METERING_ALARM_CODE_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, + EMBER_ZCL_METERING_ALARM_CODE_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, + EMBER_ZCL_METERING_ALARM_CODE_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, + EMBER_ZCL_METERING_ALARM_CODE_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_A = 0xB0, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_B = 0xB1, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_C = 0xB2, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_D = 0xB3, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_E = 0xB4, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_F = 0xB5, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_G = 0xB6, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_H = 0xB7, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_I = 0xB8, +} EmberAfMeteringAlarmCode; + +typedef enum { + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_NO_BLOCKS_IN_USE = 0x00, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK1 = 0x01, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK2 = 0x02, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK3 = 0x03, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK4 = 0x04, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK5 = 0x05, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK6 = 0x06, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK7 = 0x07, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK8 = 0x08, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK9 = 0x09, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK10 = 0x0A, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK11 = 0x0B, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK12 = 0x0C, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK13 = 0x0D, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK14 = 0x0E, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK15 = 0x0F, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK16 = 0x10, +} EmberAfMeteringBlockEnumerations; + +typedef enum { + EMBER_ZCL_METERING_CONSUMPTION_STATUS_LOW_ENERGY_USAGE = 0x00, + EMBER_ZCL_METERING_CONSUMPTION_STATUS_MEDIUM_ENERGY_USAGE = 0x01, + EMBER_ZCL_METERING_CONSUMPTION_STATUS_HIGH_ENERGY_USAGE = 0x02, +} EmberAfMeteringConsumptionStatus; + +typedef enum { + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING = 0x00, + EMBER_ZCL_METERING_DEVICE_TYPE_GAS_METERING = 0x01, + EMBER_ZCL_METERING_DEVICE_TYPE_WATER_METERING = 0x02, + EMBER_ZCL_METERING_DEVICE_TYPE_THERMAL_METERING = 0x03, + EMBER_ZCL_METERING_DEVICE_TYPE_PRESSURE_METERING = 0x04, + EMBER_ZCL_METERING_DEVICE_TYPE_HEAT_METERING = 0x05, + EMBER_ZCL_METERING_DEVICE_TYPE_COOLING_METERING = 0x06, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, + EMBER_ZCL_METERING_DEVICE_TYPE_PV_GENERATION_METERING = 0x08, + EMBER_ZCL_METERING_DEVICE_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, + EMBER_ZCL_METERING_DEVICE_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, + EMBER_ZCL_METERING_DEVICE_TYPE_MICRO_GENERATION_METERING = 0x0B, + EMBER_ZCL_METERING_DEVICE_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING = 0x7F, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_GAS_METERING = 0x80, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_METERING = 0x81, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_THERMAL_METERING = 0x82, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PRESSURE_METERING = 0x83, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_HEAT_METERING = 0x84, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_COOLING_METERING = 0x85, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_VEHICLE_CHARGING_METERING = 0x86, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PV_GENERATION_METERING = 0x87, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WIND_TURBINE_GENERATION_METERING = 0x88, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_TURBINE_GENERATION_METERING = 0x89, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_MICRO_GENERATION_METERING = 0x8A, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_SOLAR_HOT_WATER_GENERATION_METERING = 0x8B, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT1 = 0x8C, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT2 = 0x8D, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT3 = 0x8E, + EMBER_ZCL_METERING_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, +} EmberAfMeteringDeviceType; + +typedef enum { + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF = 0x00, + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_ON = 0x02, +} EmberAfMeteringSupplyStatus; + +typedef enum { + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN = 0x00, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS = 0x01, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT = 0x02, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN_BCD = 0x80, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS_BCD = 0x81, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT_BCD = 0x82, +} EmberAfMeteringTemperatureUnitOfMeasure; + +typedef enum { + EMBER_ZCL_MOVE_MODE_UP = 0x00, + EMBER_ZCL_MOVE_MODE_DOWN = 0x01, +} EmberAfMoveMode; + +typedef enum { + EMBER_ZCL_NOTIFICATION_SCHEME_NO_NOTIFICATION_SCHEME_DEFINED = 0x00, + EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_A = 0x01, + EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_B = 0x02, +} EmberAfNotificationScheme; + +typedef enum { + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR = 0x00, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_ULTRASONIC = 0x01, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR_AND_ULTRASONIC = 0x02, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PHYSICAL_CONTACT = 0x03, +} EmberAfOccupancySensorType; + +typedef enum { + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS = 0x00, + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE = 0x01, + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS = 0x02, +} EmberAfOnOffDelayedAllOffEffectVariant; + +typedef enum { + EMBER_ZCL_ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND = 0x00, +} EmberAfOnOffDyingLightEffectVariant; + +typedef enum { + EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF = 0x00, + EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT = 0x01, +} EmberAfOnOffEffectIdentifier; + +typedef enum { + EMBER_ZCL_OPERATING_MODE_NORMAL = 0x00, + EMBER_ZCL_OPERATING_MODE_CONFIGURE = 0x01, +} EmberAfOperatingMode; + +typedef enum { + EMBER_ZCL_ORIGINATING_DEVICE_ENERGY_SERVICE_INTERFACE = 0x00, + EMBER_ZCL_ORIGINATING_DEVICE_METER = 0x01, + EMBER_ZCL_ORIGINATING_DEVICE_IN_HOME_DISPLAY_DEVICE = 0x02, +} EmberAfOriginatingDevice; + +typedef enum { + EMBER_ZCL_PASSWORD_TYPE_PASSWORD1_SERVICE_MENU_ACCESS = 0x01, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD2_CONSUMER_MENU_ACCESS = 0x02, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD3 = 0x03, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD4 = 0x04, +} EmberAfPasswordType; + +typedef enum { + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_BILLING_PERIOD = 0x00, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_CONSOLIDATED_BILL = 0x01, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_MONTH = 0x02, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_QUARTER = 0x03, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_YEAR = 0x04, +} EmberAfPaymentDiscountDuration; + +typedef enum { + EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNSPECIFIED = 0x00, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_FIRST_PROFILE_SPECIFIED_VALUE = 0x01, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_LAST_PROFILE_SPECIFIED_VALUE = 0x7F, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNKNOWN = 0xFF, +} EmberAfPhysicalEnvironment; + +typedef enum { + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_WAITING_TO_START = 0x01, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_STARTED = 0x02, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_RUNNING = 0x03, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_ENDED = 0x04, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_WAITING_TO_START = 0x05, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_STARTED = 0x06, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_ENDED = 0x07, + EMBER_ZCL_POWER_PROFILE_STATE_PROFILE_READY_FOR_SCHEDULING = 0x08, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_SCHEDULED = 0x09, +} EmberAfPowerProfileState; + +typedef enum { + EMBER_ZCL_POWER_SOURCE_UNKNOWN = 0x00, + EMBER_ZCL_POWER_SOURCE_SINGLE_PHASE_MAINS = 0x01, + EMBER_ZCL_POWER_SOURCE_THREE_PHASE_MAINS = 0x02, + EMBER_ZCL_POWER_SOURCE_BATTERY = 0x03, + EMBER_ZCL_POWER_SOURCE_DC_SOURCE = 0x04, + EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_CONSTANT_POWER = 0x05, + EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_TRANSFER_SWITCH = 0x06, + EMBER_ZCL_POWER_SOURCE_BATTERY_BACKUP = 0x80, +} EmberAfPowerSource; + +typedef enum { + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_LOW_CREDIT = 0x00, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_NO_CREDIT = 0x01, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_CREDIT_EXHAUSTED = 0x02, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_ENABLED = 0x03, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_EXHAUSTED = 0x04, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_IHD_LOW_CREDIT_WARNING = 0x05, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EVENT_LOG_CLEARED = 0x06, +} EmberAfPrePayGenericAlarmGroup; + +typedef enum { + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PHYSICAL_ATTACK_ON_THE_PREPAY_METER = 0x20, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER = 0x21, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DISCOUNT_APPLIED = 0x22, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT = 0x23, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT_FAIL = 0x24, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT = 0x25, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT_FAIL = 0x26, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CHANGE = 0x27, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_ERROR = 0x28, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_ALREADY_USED = 0x29, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_INVALID = 0x2A, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_IN_USE = 0x2B, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END_WARNING = 0x2C, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END = 0x2D, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ERROR_REG_CLEAR = 0x30, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ALARM_REG_CLEAR = 0x31, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PREPAY_CLUSTER_NOT_FOUND = 0x32, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CREDIT2_PREPAY = 0x41, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_PREPAY2_CREDIT = 0x42, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_DEFAULT = 0x43, +} EmberAfPrepayEventAlarmGroup; + +typedef enum { + EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_DEBT_CREDIT_STATUS = 0x00, + EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_NOT_USED = 0xFF, +} EmberAfPrepaySnapshotPayloadType; + +typedef enum { + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ON = 0x10, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ARM = 0x11, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_OFF = 0x12, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTION_FAILURE = 0x13, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_TAMPER_DETECTED = 0x14, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_CUT_OFF_VALUE = 0x15, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_REMOTE_DISCONNECTED = 0x16, +} EmberAfPrepaySwitchAlarmGroup; + +typedef enum { + EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_NOT_REQUIRED = 0x00, + EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_REQUIRED = 0x01, +} EmberAfPriceControlAcknowledgement; + +typedef enum { + EMBER_ZCL_PRICE_TIER_NO_TIER_RELATED = 0x00, + EMBER_ZCL_PRICE_TIER_TIER1_PRICE_LABEL = 0x01, + EMBER_ZCL_PRICE_TIER_TIER2_PRICE_LABEL = 0x02, + EMBER_ZCL_PRICE_TIER_TIER3_PRICE_LABEL = 0x03, + EMBER_ZCL_PRICE_TIER_TIER4_PRICE_LABEL = 0x04, + EMBER_ZCL_PRICE_TIER_TIER5_PRICE_LABEL = 0x05, + EMBER_ZCL_PRICE_TIER_TIER6_PRICE_LABEL = 0x06, + EMBER_ZCL_PRICE_TIER_TIER7_PRICE_LABEL = 0x07, + EMBER_ZCL_PRICE_TIER_TIER8_PRICE_LABEL = 0x08, + EMBER_ZCL_PRICE_TIER_TIER9_PRICE_LABEL = 0x09, + EMBER_ZCL_PRICE_TIER_TIER10_PRICE_LABEL = 0x0A, + EMBER_ZCL_PRICE_TIER_TIER11_PRICE_LABEL = 0x0B, + EMBER_ZCL_PRICE_TIER_TIER12_PRICE_LABEL = 0x0C, + EMBER_ZCL_PRICE_TIER_TIER13_PRICE_LABEL = 0x0D, + EMBER_ZCL_PRICE_TIER_TIER14_PRICE_LABEL = 0x0E, + EMBER_ZCL_PRICE_TIER_TIER15_PRICE_LABEL = 0x0F, +} EmberAfPriceTier; + +typedef enum { + EMBER_ZCL_PRODUCT_CODE_MANUFACTURER_DEFINED = 0x00, + EMBER_ZCL_PRODUCT_CODE_ITERNATIONAL_ARTICLE_NUMBER = 0x01, + EMBER_ZCL_PRODUCT_CODE_GLOBAL_TRADE_ITEM_NUMBER = 0x02, + EMBER_ZCL_PRODUCT_CODE_UNIVERSAL_PRODUCT_CODE = 0x03, + EMBER_ZCL_PRODUCT_CODE_STOCK_KEEPING_UNIT = 0x04, +} EmberAfProductCode; + +typedef enum { + EMBER_ZCL_PRODUCT_TYPE_ID_WHITE_GOODS = 0x0000, + EMBER_ZCL_PRODUCT_TYPE_ID_DISHWASHER = 0x5601, + EMBER_ZCL_PRODUCT_TYPE_ID_TUMBLE_DRYER = 0x5602, + EMBER_ZCL_PRODUCT_TYPE_ID_WASHER_DRYER = 0x5603, + EMBER_ZCL_PRODUCT_TYPE_ID_WASHING_MACHINE = 0x5604, + EMBER_ZCL_PRODUCT_TYPE_ID_HOBS = 0x5E03, + EMBER_ZCL_PRODUCT_TYPE_ID_INDUCTION_HOBS = 0x5E09, + EMBER_ZCL_PRODUCT_TYPE_ID_OVEN = 0x5E01, + EMBER_ZCL_PRODUCT_TYPE_ID_ELECTRICAL_OVEN = 0x5E06, + EMBER_ZCL_PRODUCT_TYPE_ID_REFRIGERATOR_FREEZER = 0x6601, +} EmberAfProductTypeId; + +typedef enum { + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_RESERVED = 0x00, + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_ON = 0x02, +} EmberAfProposedSupplyStatus; + +typedef enum { + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_PENDING = 0x00, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_ACCEPTED = 0x01, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_REJECTED = 0x02, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_FORCED = 0x03, +} EmberAfPublishCppEventCppAuth; + +typedef enum { + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_SPEED = 0x00, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_PRESSURE = 0x01, + EMBER_ZCL_PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_FLOW = 0x03, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE = 0x05, + EMBER_ZCL_PUMP_CONTROL_MODE_AUTOMATIC = 0x07, +} EmberAfPumpControlMode; + +typedef enum { + EMBER_ZCL_PUMP_OPERATION_MODE_NORMAL = 0x00, + EMBER_ZCL_PUMP_OPERATION_MODE_MINIMUM = 0x01, + EMBER_ZCL_PUMP_OPERATION_MODE_MAXIMUM = 0x02, + EMBER_ZCL_PUMP_OPERATION_MODE_LOCAL = 0x03, +} EmberAfPumpOperationMode; + +typedef enum { + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_DAY = 0x0040, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_WEEK = 0x0080, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_MONTH = 0x0180, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_YEAR = 0x01C0, +} EmberAfPushHistoricalMeteringData; + +typedef enum { + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_DAY = 0x0200, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_WEEK = 0x0400, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_MONTH = 0x0C00, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_YEAR = 0x0E00, +} EmberAfPushHistoricalPaymentData; + +typedef enum { + EMBER_ZCL_REGISTER_TIER_NO_TIER_RELATED = 0x00, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, +} EmberAfRegisterTier; + +typedef enum { + EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_NOT_DISPLAYED = 0x00, + EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_DISPLAYED = 0x01, +} EmberAfRelativeHumidityDisplay; + +typedef enum { + EMBER_ZCL_RELATIVE_HUMIDITY_MODE_MEASURE_LOCALLY = 0x00, + EMBER_ZCL_RELATIVE_HUMIDITY_MODE_UPDATED_OVER_THE_NETWORK = 0x01, +} EmberAfRelativeHumidityMode; + +typedef enum { + EMBER_ZCL_REMOTE_ENABLE_FLAGS_DISABLED = 0x00, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_TEMPORARILY_LOCKED_DISABLED = 0x07, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_CONTROL = 0x0F, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_AND_ENERGY_CONTROL = 0x01, +} EmberAfRemoteEnableFlags; + +typedef enum { + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT1 = 0x00, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT2 = 0x01, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT3 = 0x02, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_ALL_DEBTS = 0xFF, +} EmberAfRepaymentDebtType; + +typedef enum { + EMBER_ZCL_REPORTING_DIRECTION_REPORTED = 0x00, + EMBER_ZCL_REPORTING_DIRECTION_RECEIVED = 0x01, +} EmberAfReportingDirection; + +typedef enum { + EMBER_ZCL_RESULT_TYPE_ACCEPTED = 0x00, + EMBER_ZCL_RESULT_TYPE_REJECTED_INVALID_TOP_UP = 0x01, + EMBER_ZCL_RESULT_TYPE_REJECTED_DUPLICATE_TOP_UP = 0x02, + EMBER_ZCL_RESULT_TYPE_REJECTED_ERROR = 0x03, + EMBER_ZCL_RESULT_TYPE_REJECTED_MAX_CREDIT_REACHED = 0x04, + EMBER_ZCL_RESULT_TYPE_REJECTED_KEYPAD_LOCK = 0x05, + EMBER_ZCL_RESULT_TYPE_REJECTED_TOP_UP_VALUE_TOO_LARGE = 0x06, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ENABLED = 0x10, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_DISABLED = 0x11, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ARMED = 0x12, +} EmberAfResultType; + +typedef enum { + EMBER_ZCL_SAMPLE_TYPE_CONSUMPTION_DELIVERED = 0x00, +} EmberAfSampleType; + +typedef enum { + EMBER_ZCL_SATURATION_MOVE_MODE_STOP = 0x00, + EMBER_ZCL_SATURATION_MOVE_MODE_UP = 0x01, + EMBER_ZCL_SATURATION_MOVE_MODE_DOWN = 0x03, +} EmberAfSaturationMoveMode; + +typedef enum { + EMBER_ZCL_SATURATION_STEP_MODE_UP = 0x01, + EMBER_ZCL_SATURATION_STEP_MODE_DOWN = 0x03, +} EmberAfSaturationStepMode; + +typedef enum { + EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, + EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_CMOS = 0x01, +} EmberAfSensingLightSensorType; + +typedef enum { + EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_SETPOINT = 0x00, + EMBER_ZCL_SETPOINT_ADJUST_MODE_COOL_SETPOINT = 0x01, + EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS = 0x02, +} EmberAfSetpointAdjustMode; + +typedef enum { + EMBER_ZCL_SIGNATURE_TYPE_RESERVED = 0x00, + EMBER_ZCL_SIGNATURE_TYPE_ECDSA = 0x01, +} EmberAfSignatureType; + +typedef enum { + EMBER_ZCL_SNAPSHOT_CONFIRMATION_ACCEPTED = 0x00, + EMBER_ZCL_SNAPSHOT_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x01, +} EmberAfSnapshotConfirmation; + +typedef enum { + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS = 0x00, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTERS = 0x01, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED = 0x02, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED = 0x03, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS_NO_BILLING = 0x04, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTER_NO_BILLINGS = 0x05, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED_NO_BILLING = 0x06, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED_NO_BILLING = 0x07, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_DATA_UNAVAILABLE = 0x80, +} EmberAfSnapshotPayloadType; + +typedef enum { + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_ACCEPTED = 0x00, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_TYPE_NOT_SUPPORTED = 0x01, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x02, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULE_NOT_CURRENTLY_AVAILABLE = 0x03, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULES_NOT_SUPPORTED_BY_DEVICE = 0x04, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_INSUFFICIENT_SPACE_FOR_SNAPSHOT_SCHEDULE = 0x05, +} EmberAfSnapshotScheduleConfirmation; + +typedef enum { + EMBER_ZCL_SQUAWK_LEVEL_LOW_LEVEL = 0x00, + EMBER_ZCL_SQUAWK_LEVEL_MEDIUM_LEVEL = 0x01, + EMBER_ZCL_SQUAWK_LEVEL_VERY_HIGH_LEVEL = 0x02, +} EmberAfSquawkLevel; + +typedef enum { + EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_ARMED = 0x00, + EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_DISARMED = 0x01, +} EmberAfSquawkMode; + +typedef enum { + EMBER_ZCL_SQUAWK_STOBE_NO_STROBE = 0x00, + EMBER_ZCL_SQUAWK_STOBE_USE_STROBE = 0x01, +} EmberAfSquawkStobe; + +typedef enum { + EMBER_ZCL_START_OF_WEEK_SUNDAY = 0x00, + EMBER_ZCL_START_OF_WEEK_MONDAY = 0x01, + EMBER_ZCL_START_OF_WEEK_TUESDAY = 0x02, + EMBER_ZCL_START_OF_WEEK_WEDNESDAY = 0x03, + EMBER_ZCL_START_OF_WEEK_THURSDAY = 0x04, + EMBER_ZCL_START_OF_WEEK_FRIDAY = 0x05, + EMBER_ZCL_START_OF_WEEK_SATURDAY = 0x06, +} EmberAfStartOfWeek; + +typedef enum { + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF = 0x00, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON = 0x01, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE = 0x02, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS = 0xFF, +} EmberAfStartUpOnOffValue; + +typedef enum { + EMBER_ZCL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_STATUS_FAILURE = 0x01, + EMBER_ZCL_STATUS_REQUEST_DENIED = 0x70, + EMBER_ZCL_STATUS_MULTIPLE_REQUEST_NOT_ALLOWED = 0x71, + EMBER_ZCL_STATUS_INDICATION_REDIRECTION_TO_AP = 0x72, + EMBER_ZCL_STATUS_PREFERENCE_DENIED = 0x73, + EMBER_ZCL_STATUS_PREFERENCE_IGNORED = 0x74, + EMBER_ZCL_STATUS_NOT_AUTHORIZED = 0x7E, + EMBER_ZCL_STATUS_RESERVED_FIELD_NOT_ZERO = 0x7F, + EMBER_ZCL_STATUS_MALFORMED_COMMAND = 0x80, + EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND = 0x81, + EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND = 0x82, + EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND = 0x83, + EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND = 0x84, + EMBER_ZCL_STATUS_INVALID_FIELD = 0x85, + EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE = 0x86, + EMBER_ZCL_STATUS_INVALID_VALUE = 0x87, + EMBER_ZCL_STATUS_READ_ONLY = 0x88, + EMBER_ZCL_STATUS_INSUFFICIENT_SPACE = 0x89, + EMBER_ZCL_STATUS_DUPLICATE_EXISTS = 0x8A, + EMBER_ZCL_STATUS_NOT_FOUND = 0x8B, + EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE = 0x8C, + EMBER_ZCL_STATUS_INVALID_DATA_TYPE = 0x8D, + EMBER_ZCL_STATUS_INVALID_SELECTOR = 0x8E, + EMBER_ZCL_STATUS_WRITE_ONLY = 0x8F, + EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE = 0x90, + EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND = 0x91, + EMBER_ZCL_STATUS_INCONSISTENT = 0x92, + EMBER_ZCL_STATUS_ACTION_DENIED = 0x93, + EMBER_ZCL_STATUS_TIMEOUT = 0x94, + EMBER_ZCL_STATUS_ABORT = 0x95, + EMBER_ZCL_STATUS_INVALID_IMAGE = 0x96, + EMBER_ZCL_STATUS_WAIT_FOR_DATA = 0x97, + EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE = 0x98, + EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE = 0x99, + EMBER_ZCL_STATUS_HARDWARE_FAILURE = 0xC0, + EMBER_ZCL_STATUS_SOFTWARE_FAILURE = 0xC1, + EMBER_ZCL_STATUS_CALIBRATION_ERROR = 0xC2, + EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER = 0xC3, +} EmberAfStatus; + +typedef enum { + EMBER_ZCL_STEP_MODE_UP = 0x00, + EMBER_ZCL_STEP_MODE_DOWN = 0x01, +} EmberAfStepMode; + +typedef enum { + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF = 0x00, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_ON = 0x02, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_UNCHANGED = 0x03, +} EmberAfSupplyStatus; + +typedef enum { + EMBER_ZCL_SWITCH_ACTIONS_ON = 0x00, + EMBER_ZCL_SWITCH_ACTIONS_OFF = 0x01, + EMBER_ZCL_SWITCH_ACTIONS_TOGGLE = 0x02, +} EmberAfSwitchActions; + +typedef enum { + EMBER_ZCL_SWITCH_TYPE_TOGGLE = 0x00, + EMBER_ZCL_SWITCH_TYPE_MOMENTARY = 0x01, + EMBER_ZCL_SWITCH_TYPE_MULTI_FUNCTION = 0x02, +} EmberAfSwitchType; + +typedef enum { + EMBER_ZCL_TARIFF_CHARGING_SCHEME_TOU_TARIFF = 0x00, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TARIFF = 0x10, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_COMMON_THRESHOLDS = 0x20, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_INDIVIDUAL_THRESHOLDS_PER_TIER = 0x30, +} EmberAfTariffChargingScheme; + +typedef enum { + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_NOT_DEFINED = 0x00, + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_BLOCK_PERIOD = 0x01, + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_ONE_DAY = 0x02, +} EmberAfTariffResolutionPeriod; + +typedef enum { + EMBER_ZCL_TARIFF_TYPE_DELIVERED_TARIFF = 0x00, + EMBER_ZCL_TARIFF_TYPE_RECEIVED_TARIFF = 0x01, + EMBER_ZCL_TARIFF_TYPE_DELIVERED_AND_RECEIVED_TARIFF = 0x02, +} EmberAfTariffType; + +typedef enum { + EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_CELSIUS = 0x00, + EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_FAHRENHEIT = 0x01, +} EmberAfTemperatureDisplayMode; + +typedef enum { + EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_OFF = 0x00, + EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_ON = 0x01, +} EmberAfTemperatureSetpointHold; + +typedef enum { + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_ONLY = 0x00, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_WITH_REHEAT = 0x01, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_ONLY = 0x02, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_WITH_REHEAT = 0x03, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING = 0x04, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING_WITH_REHEAT = 0x05, +} EmberAfThermostatControlSequence; + +typedef enum { + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_OFF = 0x00, + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_COOL = 0x03, + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_HEAT = 0x04, +} EmberAfThermostatRunningMode; + +typedef enum { + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_OFF = 0x00, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_AUTO = 0x01, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_COOL = 0x03, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_HEAT = 0x04, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_EMERGENCY_HEATING = 0x05, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_PRECOOLING = 0x06, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_FAN_ONLY = 0x07, +} EmberAfThermostatSystemMode; + +typedef enum { + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK = 0x00, + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER = 0x01, + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER_THRESHOLD = 0x02, + EMBER_ZCL_TIER_BLOCK_MODE_NOT_USED = 0xFF, +} EmberAfTierBlockMode; + +typedef enum { + EMBER_ZCL_TIME_ENCODING_RELATIVE = 0x00, + EMBER_ZCL_TIME_ENCODING_ABSOLUTE = 0x40, +} EmberAfTimeEncoding; + +typedef enum { + EMBER_ZCL_TUNNELING_PROTOCOL_ID_DLMS_COSEM = 0x00, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_IEC_61107 = 0x01, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_ANSI_C12 = 0x02, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_M_BUS = 0x03, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_SML = 0x04, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_CLIMATE_TALK = 0x05, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_GB_HRGP = 0x06, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_TEST = 0xC7, +} EmberAfTunnelingProtocolId; + +typedef enum { + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_NO_SUCH_TUNNEL = 0x00, + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_WRONG_DEVICE = 0x01, + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_DATA_OVERFLOW = 0x02, +} EmberAfTunnelingTransferDataStatus; + +typedef enum { + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_BUSY = 0x01, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_NO_MORE_TUNNEL_IDS = 0x02, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_PROTOCOL_NOT_SUPPORTED = 0x03, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_FLOW_CONTROL_NOT_SUPPORTED = 0x04, +} EmberAfTunnelingTunnelStatus; + +typedef enum { + EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_NOT_AVAILABLE = 0x00, + EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_AVAILABLE = 0x01, +} EmberAfWanStatus; + +typedef enum { + EMBER_ZCL_WARNING_EVENT_WARNING1_OVERALL_POWER_ABOVE_AVAILABLE_POWER_LEVEL = 0x00, + EMBER_ZCL_WARNING_EVENT_WARNING2_OVERALL_POWER_ABOVE_POWER_THRESHOLD_LEVEL = 0x01, + EMBER_ZCL_WARNING_EVENT_WARNING3_OVERALL_POWER_BACK_BELOW_THE_AVAILABLE_POWER_LEVEL = 0x02, + EMBER_ZCL_WARNING_EVENT_WARNING4_OVERALL_POWER_BACK_BELOW_THE_POWER_THRESHOLD_LEVEL = 0x03, + EMBER_ZCL_WARNING_EVENT_WARNING5_OVERALL_POWER_WILL_BE_POTENTIALLY_ABOVE_AVAILABLE_POWER_LEVEL_IF_THE_APPLIANCE_STARTS = 0x04, +} EmberAfWarningEvent; + +typedef enum { + EMBER_ZCL_WARNING_MODE_STOP = 0x00, + EMBER_ZCL_WARNING_MODE_BURGLAR = 0x01, + EMBER_ZCL_WARNING_MODE_FIRE = 0x02, + EMBER_ZCL_WARNING_MODE_EMERGENCY = 0x03, + EMBER_ZCL_WARNING_MODE_POLICE_PANIC = 0x04, + EMBER_ZCL_WARNING_MODE_FIRE_PANIC = 0x05, + EMBER_ZCL_WARNING_MODE_EMERGENCY_PANIC = 0x06, +} EmberAfWarningMode; + +typedef enum { + EMBER_ZCL_WARNING_STOBE_NO_STROBE = 0x00, + EMBER_ZCL_WARNING_STOBE_USE_STROBE = 0x01, +} EmberAfWarningStobe; + +typedef enum { + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_TRIP_TO_PAIR = 0x00, + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_AUTO_ENROLLMENT_RESPONSE = 0x01, + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_REQUEST = 0x02, +} EmberAfWwahIasZoneEnrollmentMode; + +typedef enum { + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_UNKNOWN = 0x00, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BATTERY = 0x01, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BROWNOUT = 0x02, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_WATCHDOG = 0x03, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_RESET_PIN = 0x04, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_MEMORY_HARDWARE_FAULT = 0x05, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFWARE_EXCEPTION = 0x06, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_OTA_BOOTLOAD_SUCCESS = 0x07, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFTWARE_RESET = 0x08, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_POWER_BUTTON = 0x09, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_TEMPERATURE = 0x0A, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BOOTLOAD_FAILURE = 0x0B, +} EmberAfWwahPowerNotificationReason; + +typedef enum { + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_COORDINATOR = 0x00, + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_ROUTER = 0x01, + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_END_DEVICE = 0x02, +} EmberAfZigbeeInformationLogicalType; + +typedef enum { + EMBER_ZCL_ZLL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_ZLL_STATUS_FAILURE = 0x01, +} EmberAfZllStatus; + + +#define EMBER_AF_SHADE_CLOSURE_STATUS_OPERATIONAL (0x01) +#define EMBER_AF_SHADE_CLOSURE_STATUS_ADJUSTING (0x02) +#define EMBER_AF_SHADE_CLOSURE_STATUS_ADJUSTING_OFFSET (1) +#define EMBER_AF_SHADE_CLOSURE_STATUS_OPENING (0x04) +#define EMBER_AF_SHADE_CLOSURE_STATUS_OPENING_OFFSET (2) +#define EMBER_AF_SHADE_CLOSURE_STATUS_MOTOR_OPENING (0x08) +#define EMBER_AF_SHADE_CLOSURE_STATUS_MOTOR_OPENING_OFFSET (3) +#define EMBER_AF_ALARM_MASK_GENERAL_HW_FAULT (0x01) +#define EMBER_AF_ALARM_MASK_GENERAL_SW_FAULT (0x02) +#define EMBER_AF_ALARM_MASK_GENERAL_SW_FAULT_OFFSET (1) +#define EMBER_AF_RESTART_OPTIONS_START_MODE1 (0x01) +#define EMBER_AF_RESTART_OPTIONS_STARTUP_MODE2 (0x02) +#define EMBER_AF_RESTART_OPTIONS_STARTUP_MODE2_OFFSET (1) +#define EMBER_AF_RESTART_OPTIONS_STARTUP_MODE3 (0x04) +#define EMBER_AF_RESTART_OPTIONS_STARTUP_MODE3_OFFSET (2) +#define EMBER_AF_RESTART_OPTIONS_IMMEDIATE (0x08) +#define EMBER_AF_RESTART_OPTIONS_IMMEDIATE_OFFSET (3) +#define EMBER_AF_RESET_OPTIONS_RESET_CURRENT (0x01) +#define EMBER_AF_RESET_OPTIONS_RESET_ALL (0x02) +#define EMBER_AF_RESET_OPTIONS_RESET_ALL_OFFSET (1) +#define EMBER_AF_RESET_OPTIONS_ERASE_INDEX (0x04) +#define EMBER_AF_RESET_OPTIONS_ERASE_INDEX_OFFSET (2) +#define EMBER_AF_MAINS_ALARM_MASK_VOLTAGE_TOO_LOW (0x01) +#define EMBER_AF_MAINS_ALARM_MASK_VOLTAGE_TOO_HIGH (0x02) +#define EMBER_AF_MAINS_ALARM_MASK_VOLTAGE_TOO_HIGH_OFFSET (1) +#define EMBER_AF_MAINS_ALARM_MASK_MAINS_POWER_SUPPLY_LOST (0x04) +#define EMBER_AF_MAINS_ALARM_MASK_MAINS_POWER_SUPPLY_LOST_OFFSET (2) +#define EMBER_AF_BATTERY_ALARM_MASK_VOLTAGE_TOO_LOW (0x01) +#define EMBER_AF_DEVICE_TEMP_ALARM_MASK_TOO_LOW (0x01) +#define EMBER_AF_DEVICE_TEMP_ALARM_MASK_TOO_HIGH (0x02) +#define EMBER_AF_DEVICE_TEMP_ALARM_MASK_TOO_HIGH_OFFSET (1) +#define EMBER_AF_TIME_STATUS_MASK_MASTER_CLOCK (0x01) +#define EMBER_AF_TIME_STATUS_MASK_SYNCHRONIZED (0x02) +#define EMBER_AF_TIME_STATUS_MASK_SYNCHRONIZED_OFFSET (1) +#define EMBER_AF_TIME_STATUS_MASK_MASTER_ZONE_DST (0x04) +#define EMBER_AF_TIME_STATUS_MASK_MASTER_ZONE_DST_OFFSET (2) +#define EMBER_AF_TIME_STATUS_MASK_SUPERSEDING (0x08) +#define EMBER_AF_TIME_STATUS_MASK_SUPERSEDING_OFFSET (3) +#define EMBER_AF_LOCATION_TYPE_ABSOLUTE (0x01) +#define EMBER_AF_LOCATION_TYPE2_D (0x02) +#define EMBER_AF_LOCATION_TYPE2_D_OFFSET (1) +#define EMBER_AF_LOCATION_TYPE_COORDINATE_SYSTEM (0x0C) +#define EMBER_AF_LOCATION_TYPE_COORDINATE_SYSTEM_OFFSET (2) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_ABSOLUTE_ONLY (0x01) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_RECALCULATE (0x02) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_RECALCULATE_OFFSET (1) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_BROADCAST (0x04) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_BROADCAST_OFFSET (2) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_BROADCAST_RESPONSE (0x08) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_BROADCAST_RESPONSE_OFFSET (3) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_COMPACT_RESPONSE (0x10) +#define EMBER_AF_GET_LOCATION_DATA_FLAGS_COMPACT_RESPONSE_OFFSET (4) +#define EMBER_AF_PUMP_STATUS_DEVICE_FAULT (0x0001) +#define EMBER_AF_PUMP_STATUS_SUPPLYFAULT (0x0002) +#define EMBER_AF_PUMP_STATUS_SUPPLYFAULT_OFFSET (1) +#define EMBER_AF_PUMP_STATUS_SPEED_LOW (0x0004) +#define EMBER_AF_PUMP_STATUS_SPEED_LOW_OFFSET (2) +#define EMBER_AF_PUMP_STATUS_SPEED_HIGH (0x0008) +#define EMBER_AF_PUMP_STATUS_SPEED_HIGH_OFFSET (3) +#define EMBER_AF_PUMP_STATUS_LOCAL_OVERRIDE (0x0010) +#define EMBER_AF_PUMP_STATUS_LOCAL_OVERRIDE_OFFSET (4) +#define EMBER_AF_PUMP_STATUS_RUNNING (0x0020) +#define EMBER_AF_PUMP_STATUS_RUNNING_OFFSET (5) +#define EMBER_AF_PUMP_STATUS_REMOTE_PRESSURE (0x0040) +#define EMBER_AF_PUMP_STATUS_REMOTE_PRESSURE_OFFSET (6) +#define EMBER_AF_PUMP_STATUS_REMOTE_FLOW (0x0080) +#define EMBER_AF_PUMP_STATUS_REMOTE_FLOW_OFFSET (7) +#define EMBER_AF_PUMP_STATUS_REMOTE_TEMPERATURE (0x0100) +#define EMBER_AF_PUMP_STATUS_REMOTE_TEMPERATURE_OFFSET (8) +#define EMBER_AF_PUMP_ALARM_MASK_SUPPLY_VOLTAGE_TOO_LOW (0x0001) +#define EMBER_AF_PUMP_ALARM_MASK_SUPPLY_VOLTAGE_TOO_HIGH (0x0002) +#define EMBER_AF_PUMP_ALARM_MASK_SUPPLY_VOLTAGE_TOO_HIGH_OFFSET (1) +#define EMBER_AF_PUMP_ALARM_MASK_POWER_MISSING_PHASE (0x0004) +#define EMBER_AF_PUMP_ALARM_MASK_POWER_MISSING_PHASE_OFFSET (2) +#define EMBER_AF_PUMP_ALARM_MASK_SYSTEM_PRESSURE_TOO_LOW (0x0008) +#define EMBER_AF_PUMP_ALARM_MASK_SYSTEM_PRESSURE_TOO_LOW_OFFSET (3) +#define EMBER_AF_PUMP_ALARM_MASK_SYSTEM_PRESSURE_TOO_HIGH (0x0010) +#define EMBER_AF_PUMP_ALARM_MASK_SYSTEM_PRESSURE_TOO_HIGH_OFFSET (4) +#define EMBER_AF_PUMP_ALARM_MASK_DRY_RUNNING (0x0020) +#define EMBER_AF_PUMP_ALARM_MASK_DRY_RUNNING_OFFSET (5) +#define EMBER_AF_PUMP_ALARM_MASK_MOTOR_TEMPERATURE_TOO_HIGH (0x0040) +#define EMBER_AF_PUMP_ALARM_MASK_MOTOR_TEMPERATURE_TOO_HIGH_OFFSET (6) +#define EMBER_AF_PUMP_ALARM_MASK_PUMP_MOTOR_HAS_FATAL_FAILURE (0x0080) +#define EMBER_AF_PUMP_ALARM_MASK_PUMP_MOTOR_HAS_FATAL_FAILURE_OFFSET (7) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_TEMPERATURE_TOO_HIGH (0x0100) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_TEMPERATURE_TOO_HIGH_OFFSET (8) +#define EMBER_AF_PUMP_ALARM_MASK_PUMP_BLOCKED (0x0200) +#define EMBER_AF_PUMP_ALARM_MASK_PUMP_BLOCKED_OFFSET (9) +#define EMBER_AF_PUMP_ALARM_MASK_SENSOR_FAILURE (0x0400) +#define EMBER_AF_PUMP_ALARM_MASK_SENSOR_FAILURE_OFFSET (10) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_NON_FATAL_FAILURE (0x0800) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_NON_FATAL_FAILURE_OFFSET (11) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_FATAL_FAILURE (0x1000) +#define EMBER_AF_PUMP_ALARM_MASK_ELECTRONIC_FATAL_FAILURE_OFFSET (12) +#define EMBER_AF_PUMP_ALARM_MASK_GENERAL_FAULT (0x2000) +#define EMBER_AF_PUMP_ALARM_MASK_GENERAL_FAULT_OFFSET (13) +#define EMBER_AF_THERMOSTAT_OCCUPANCY_OCCUPIED (0x01) +#define EMBER_AF_THERMOSTAT_SENSING_LOCAL_TEMP_SENSED_REMOTELY (0x01) +#define EMBER_AF_THERMOSTAT_SENSING_OUTDOOR_TEMP_SENSED_REMOTELY (0x02) +#define EMBER_AF_THERMOSTAT_SENSING_OUTDOOR_TEMP_SENSED_REMOTELY_OFFSET (1) +#define EMBER_AF_THERMOSTAT_SENSING_OCCUPANCY_SENSED_REMOTELY (0x04) +#define EMBER_AF_THERMOSTAT_SENSING_OCCUPANCY_SENSED_REMOTELY_OFFSET (2) +#define EMBER_AF_THERMOSTAT_ALARM_MASK_INITIALIZATION_FAILURE (0x01) +#define EMBER_AF_THERMOSTAT_ALARM_MASK_HARDWARE_FAILURE (0x02) +#define EMBER_AF_THERMOSTAT_ALARM_MASK_HARDWARE_FAILURE_OFFSET (1) +#define EMBER_AF_THERMOSTAT_ALARM_MASK_SELFCALIBRATION_FAILURE (0x04) +#define EMBER_AF_THERMOSTAT_ALARM_MASK_SELFCALIBRATION_FAILURE_OFFSET (2) +#define EMBER_AF_BALLAST_STATUS_NON_OPERATIONAL (0x01) +#define EMBER_AF_BALLAST_STATUS_LAMP_NOT_IN_SOCKET (0x02) +#define EMBER_AF_BALLAST_STATUS_LAMP_NOT_IN_SOCKET_OFFSET (1) +#define EMBER_AF_LAMP_ALARM_MODE_LAMP_BURN_HOURS (0x01) +#define EMBER_AF_OCCUPANCY_OCCUPIED (0x01) +#define EMBER_AF_IAS_ZONE_STATUS_ALARM1 (0x0001) +#define EMBER_AF_IAS_ZONE_STATUS_ALARM2 (0x0002) +#define EMBER_AF_IAS_ZONE_STATUS_ALARM2_OFFSET (1) +#define EMBER_AF_IAS_ZONE_STATUS_TAMPER (0x0004) +#define EMBER_AF_IAS_ZONE_STATUS_TAMPER_OFFSET (2) +#define EMBER_AF_IAS_ZONE_STATUS_BATTERY (0x0008) +#define EMBER_AF_IAS_ZONE_STATUS_BATTERY_OFFSET (3) +#define EMBER_AF_IAS_ZONE_STATUS_SUPERVISION_REPORTS (0x0010) +#define EMBER_AF_IAS_ZONE_STATUS_SUPERVISION_REPORTS_OFFSET (4) +#define EMBER_AF_IAS_ZONE_STATUS_RESTORE_REPORTS (0x0020) +#define EMBER_AF_IAS_ZONE_STATUS_RESTORE_REPORTS_OFFSET (5) +#define EMBER_AF_IAS_ZONE_STATUS_TROUBLE (0x0040) +#define EMBER_AF_IAS_ZONE_STATUS_TROUBLE_OFFSET (6) +#define EMBER_AF_IAS_ZONE_STATUS_A_C (0x0080) +#define EMBER_AF_IAS_ZONE_STATUS_A_C_OFFSET (7) +#define EMBER_AF_IAS_ZONE_STATUS_TEST (0x0100) +#define EMBER_AF_IAS_ZONE_STATUS_TEST_OFFSET (8) +#define EMBER_AF_IAS_ZONE_STATUS_BATTERY_DEFECT (0x0200) +#define EMBER_AF_IAS_ZONE_STATUS_BATTERY_DEFECT_OFFSET (9) +#define EMBER_AF_WARNING_INFO_MODE (0xF0) +#define EMBER_AF_WARNING_INFO_MODE_OFFSET (4) +#define EMBER_AF_WARNING_INFO_STROBE (0x0C) +#define EMBER_AF_WARNING_INFO_STROBE_OFFSET (2) +#define EMBER_AF_WARNING_INFO_SIREN_LEVEL (0x03) +#define EMBER_AF_SQUAWK_INFO_MODE (0xF0) +#define EMBER_AF_SQUAWK_INFO_MODE_OFFSET (4) +#define EMBER_AF_SQUAWK_INFO_STROBE (0x08) +#define EMBER_AF_SQUAWK_INFO_STROBE_OFFSET (3) +#define EMBER_AF_SQUAWK_INFO_LEVEL (0x03) +#define EMBER_AF_OCCUPANCY_SENSOR_TYPE_BITMAP_PIR (0x01) +#define EMBER_AF_OCCUPANCY_SENSOR_TYPE_BITMAP_ULTRASONIC (0x02) +#define EMBER_AF_OCCUPANCY_SENSOR_TYPE_BITMAP_ULTRASONIC_OFFSET (1) +#define EMBER_AF_OCCUPANCY_SENSOR_TYPE_BITMAP_PHYSICAL_CONTACT (0x04) +#define EMBER_AF_OCCUPANCY_SENSOR_TYPE_BITMAP_PHYSICAL_CONTACT_OFFSET (2) +#define EMBER_AF_ENERGY_FORMATTING_NUMBER_OF_DIGITS_TO_THE_RIGHT_OF_THE_DECIMAL_POINT (0x07) +#define EMBER_AF_ENERGY_FORMATTING_NUMBER_OF_DIGITS_TO_THE_LEFT_OF_THE_DECIMAL_POINT (0x78) +#define EMBER_AF_ENERGY_FORMATTING_NUMBER_OF_DIGITS_TO_THE_LEFT_OF_THE_DECIMAL_POINT_OFFSET (3) +#define EMBER_AF_ENERGY_FORMATTING_SUPPRESS_LEADING_ZEROS (0x80) +#define EMBER_AF_ENERGY_FORMATTING_SUPPRESS_LEADING_ZEROS_OFFSET (7) +#define EMBER_AF_REMOTE_ENABLE_FLAGS_AND_DEVICE_STATUS2_REMOTE_ENABLE_FLAGS (0x0F) +#define EMBER_AF_REMOTE_ENABLE_FLAGS_AND_DEVICE_STATUS2_DEVICE_STATUS2_STRUCTURE (0xF0) +#define EMBER_AF_REMOTE_ENABLE_FLAGS_AND_DEVICE_STATUS2_DEVICE_STATUS2_STRUCTURE_OFFSET (4) +#define EMBER_AF_START_TIME_MINUTES (0x003F) +#define EMBER_AF_START_TIME_TIME_ENCODING (0x00C0) +#define EMBER_AF_START_TIME_TIME_ENCODING_OFFSET (6) +#define EMBER_AF_START_TIME_HOURS (0xFF00) +#define EMBER_AF_START_TIME_HOURS_OFFSET (8) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_SUNDAY (0x01) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_MONDAY (0x02) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_MONDAY_OFFSET (1) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_TUESDAY (0x04) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_TUESDAY_OFFSET (2) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_WEDNESDAY (0x08) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_WEDNESDAY_OFFSET (3) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_THURSDAY (0x10) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_THURSDAY_OFFSET (4) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_FRIDAY (0x20) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_FRIDAY_OFFSET (5) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_SATURDAY (0x40) +#define EMBER_AF_DOOR_LOCK_DAY_OF_WEEK_SATURDAY_OFFSET (6) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_HEAT_STATE_ON (0x0001) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_COOL_STATE_ON (0x0002) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_COOL_STATE_ON_OFFSET (1) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_STATE_ON (0x0004) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_STATE_ON_OFFSET (2) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_HEAT_SECOND_STAGE_STATE_ON (0x0008) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_HEAT_SECOND_STAGE_STATE_ON_OFFSET (3) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_COOL_SECOND_STAGE_STATE_ON (0x0010) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_COOL_SECOND_STAGE_STATE_ON_OFFSET (4) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_SECOND_STAGE_STATE_ON (0x0020) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_SECOND_STAGE_STATE_ON_OFFSET (5) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_THIRD_STAGE_STATE_ON (0x0040) +#define EMBER_AF_THERMOSTAT_RUNNING_STATE_FAN_THIRD_STAGE_STATE_ON_OFFSET (6) +#define EMBER_AF_DAY_OF_WEEK_SUNDAY (0x01) +#define EMBER_AF_DAY_OF_WEEK_MONDAY (0x02) +#define EMBER_AF_DAY_OF_WEEK_MONDAY_OFFSET (1) +#define EMBER_AF_DAY_OF_WEEK_TUESDAY (0x04) +#define EMBER_AF_DAY_OF_WEEK_TUESDAY_OFFSET (2) +#define EMBER_AF_DAY_OF_WEEK_WEDNESDAY (0x08) +#define EMBER_AF_DAY_OF_WEEK_WEDNESDAY_OFFSET (3) +#define EMBER_AF_DAY_OF_WEEK_THURSDAY (0x10) +#define EMBER_AF_DAY_OF_WEEK_THURSDAY_OFFSET (4) +#define EMBER_AF_DAY_OF_WEEK_FRIDAY (0x20) +#define EMBER_AF_DAY_OF_WEEK_FRIDAY_OFFSET (5) +#define EMBER_AF_DAY_OF_WEEK_SATURDAY (0x40) +#define EMBER_AF_DAY_OF_WEEK_SATURDAY_OFFSET (6) +#define EMBER_AF_DAY_OF_WEEK_AWAY_OR_VACATION (0x80) +#define EMBER_AF_DAY_OF_WEEK_AWAY_OR_VACATION_OFFSET (7) +#define EMBER_AF_MODE_FOR_SEQUENCE_HEAT_SETPOINT_FIELD_PRESENT (0x01) +#define EMBER_AF_MODE_FOR_SEQUENCE_COOL_SETPOINT_FIELD_PRESENT (0x02) +#define EMBER_AF_MODE_FOR_SEQUENCE_COOL_SETPOINT_FIELD_PRESENT_OFFSET (1) +#define EMBER_AF_ALERT_STRUCTURE_ALERT_ID (0x0000FF) +#define EMBER_AF_ALERT_STRUCTURE_CATEGORY (0x000F00) +#define EMBER_AF_ALERT_STRUCTURE_CATEGORY_OFFSET (8) +#define EMBER_AF_ALERT_STRUCTURE_PRESENCE_RECOVERY (0x003000) +#define EMBER_AF_ALERT_STRUCTURE_PRESENCE_RECOVERY_OFFSET (12) +#define EMBER_AF_ALERT_COUNT_NUMBER_OF_ALERTS (0x0F) +#define EMBER_AF_ALERT_COUNT_TYPE_OF_ALERT (0xF0) +#define EMBER_AF_ALERT_COUNT_TYPE_OF_ALERT_OFFSET (4) +#define EMBER_AF_BARRIER_CONTROL_CAPABILITIES_PARTIAL_BARRIER (0x01) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_REMOTE_LOCKOUT (0x0001) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_TEMPER_DETECTED (0x0002) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_TEMPER_DETECTED_OFFSET (1) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_FAILED_COMMUNICATION (0x0004) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_FAILED_COMMUNICATION_OFFSET (2) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_POSITION_FAILURE (0x0008) +#define EMBER_AF_BARRIER_CONTROL_SAFETY_STATUS_POSITION_FAILURE_OFFSET (3) +#define EMBER_AF_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE (0x0F) +#define EMBER_AF_BLOCK_PERIOD_DURATION_TYPE_CONTROL (0xF0) +#define EMBER_AF_BLOCK_PERIOD_DURATION_TYPE_CONTROL_OFFSET (4) +#define EMBER_AF_CONVERSION_FACTOR_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_CONVERSION_FACTOR_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_CALORIFIC_VALUE_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_CALORIFIC_VALUE_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_PRICE_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_PRICE_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_C_O2_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_C_O2_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_PRICE_TRAILING_DIGIT_AND_PRICE_TIER_PRICE_TIER (0x0F) +#define EMBER_AF_PRICE_TRAILING_DIGIT_AND_PRICE_TIER_TRAILING_DIGIT (0xF0) +#define EMBER_AF_PRICE_TRAILING_DIGIT_AND_PRICE_TIER_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_PRICE_NUMBER_OF_PRICE_TIERS_AND_REGISTER_TIER_REGISTER_TIER (0x0F) +#define EMBER_AF_PRICE_NUMBER_OF_PRICE_TIERS_AND_REGISTER_TIER_NUMBER_OF_PRICE_TIERS (0xF0) +#define EMBER_AF_PRICE_NUMBER_OF_PRICE_TIERS_AND_REGISTER_TIER_NUMBER_OF_PRICE_TIERS_OFFSET (4) +#define EMBER_AF_ALTERNATE_COST_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_ALTERNATE_COST_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_PRICE_CONTROL_MASK_PRICE_ACKNOWLEDGEMENT_REQUIRED (0x01) +#define EMBER_AF_PRICE_CONTROL_MASK_TOTAL_TIERS_EXCEEDS15 (0x02) +#define EMBER_AF_PRICE_CONTROL_MASK_TOTAL_TIERS_EXCEEDS15_OFFSET (1) +#define EMBER_AF_BLOCK_PERIOD_CONTROL_PRICE_ACKNOWLEDGEMENT_REQUIREMENT (0x01) +#define EMBER_AF_BLOCK_PERIOD_CONTROL_REPEATING_BLOCK (0x02) +#define EMBER_AF_BLOCK_PERIOD_CONTROL_REPEATING_BLOCK_OFFSET (1) +#define EMBER_AF_TARIFF_TYPE_CHARGING_SCHEME_TARIFF_TYPE (0x0F) +#define EMBER_AF_TARIFF_TYPE_CHARGING_SCHEME_TARIFF_CHARGING_SCHEME (0xF0) +#define EMBER_AF_TARIFF_TYPE_CHARGING_SCHEME_TARIFF_CHARGING_SCHEME_OFFSET (4) +#define EMBER_AF_PRICE_MATRIX_SUB_PAYLOAD_CONTROL_TOU_BASED (0x01) +#define EMBER_AF_BLOCK_THRESHOLD_SUB_PAYLOAD_CONTROL_APPLY_TO_ALL_TOU_TIERS_OR_WHEN_BLOCK_ONLY_CHARGING (0x01) +#define EMBER_AF_BILLING_PERIOD_DURATION_DURATION (0x3FFFFF) +#define EMBER_AF_BILLING_PERIOD_DURATION_UNITS (0xC00000) +#define EMBER_AF_BILLING_PERIOD_DURATION_UNITS_OFFSET (22) +#define EMBER_AF_BILLING_PERIOD_DURATION_TYPE_TIMEBASE (0x0F) +#define EMBER_AF_BILLING_PERIOD_DURATION_TYPE_CONTROL (0xF0) +#define EMBER_AF_BILLING_PERIOD_DURATION_TYPE_CONTROL_OFFSET (4) +#define EMBER_AF_BILL_TRAILING_DIGIT_TRAILING_DIGIT (0xF0) +#define EMBER_AF_BILL_TRAILING_DIGIT_TRAILING_DIGIT_OFFSET (4) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CLEAR_BILLING_INFO (0x00000001) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CONVERT_BILLING_INFO_USING_NEW_CURRENCY (0x00000002) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CONVERT_BILLING_INFO_USING_NEW_CURRENCY_OFFSET (1) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CLEAR_OLD_CONSUMPTION_DATA (0x00000004) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CLEAR_OLD_CONSUMPTION_DATA_OFFSET (2) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CONVERT_OLD_CONSUMPTION_DATA_USING_NEW_CURRENCY (0x00000008) +#define EMBER_AF_CURRENCY_CHANGE_CONTROL_CONVERT_OLD_CONSUMPTION_DATA_USING_NEW_CURRENCY_OFFSET (3) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER1 (0x0002) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER1_OFFSET (1) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER2 (0x0004) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER2_OFFSET (2) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER3 (0x0008) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER3_OFFSET (3) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER4 (0x0010) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER4_OFFSET (4) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER5 (0x0020) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER5_OFFSET (5) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER6 (0x0040) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER6_OFFSET (6) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER7 (0x0080) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER7_OFFSET (7) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER8 (0x0100) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER8_OFFSET (8) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER9 (0x0200) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER9_OFFSET (9) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER10 (0x0400) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER10_OFFSET (10) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER11 (0x0800) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER11_OFFSET (11) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER12 (0x1000) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER12_OFFSET (12) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER13 (0x2000) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER13_OFFSET (13) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER14 (0x4000) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER14_OFFSET (14) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER15 (0x8000) +#define EMBER_AF_BLOCK_THRESHOLD_MASK_TIER15_OFFSET (15) +#define EMBER_AF_AMI_COMMAND_OPTIONS_REQUEST_RX_ON_WHEN_IDLE (0x01) +#define EMBER_AF_AMI_DEVICE_CLASS_HVAC_COMPRESSOR_OR_FURNACE (0x0001) +#define EMBER_AF_AMI_DEVICE_CLASS_STRIP_HEAT_BASEBOARD_HEAT (0x0002) +#define EMBER_AF_AMI_DEVICE_CLASS_STRIP_HEAT_BASEBOARD_HEAT_OFFSET (1) +#define EMBER_AF_AMI_DEVICE_CLASS_WATER_HEATER (0x0004) +#define EMBER_AF_AMI_DEVICE_CLASS_WATER_HEATER_OFFSET (2) +#define EMBER_AF_AMI_DEVICE_CLASS_POOL_PUMP_SPA_JACUZZI (0x0008) +#define EMBER_AF_AMI_DEVICE_CLASS_POOL_PUMP_SPA_JACUZZI_OFFSET (3) +#define EMBER_AF_AMI_DEVICE_CLASS_SMART_APPLIANCES (0x0010) +#define EMBER_AF_AMI_DEVICE_CLASS_SMART_APPLIANCES_OFFSET (4) +#define EMBER_AF_AMI_DEVICE_CLASS_IRRIGATION_PUMP (0x0020) +#define EMBER_AF_AMI_DEVICE_CLASS_IRRIGATION_PUMP_OFFSET (5) +#define EMBER_AF_AMI_DEVICE_CLASS_MANAGED_C_AND_I_LOADS (0x0040) +#define EMBER_AF_AMI_DEVICE_CLASS_MANAGED_C_AND_I_LOADS_OFFSET (6) +#define EMBER_AF_AMI_DEVICE_CLASS_SIMPLE_MISC_LOADS (0x0080) +#define EMBER_AF_AMI_DEVICE_CLASS_SIMPLE_MISC_LOADS_OFFSET (7) +#define EMBER_AF_AMI_DEVICE_CLASS_EXTERIOR_LIGHTING (0x0100) +#define EMBER_AF_AMI_DEVICE_CLASS_EXTERIOR_LIGHTING_OFFSET (8) +#define EMBER_AF_AMI_DEVICE_CLASS_INTERIOR_LIGHTING (0x0200) +#define EMBER_AF_AMI_DEVICE_CLASS_INTERIOR_LIGHTING_OFFSET (9) +#define EMBER_AF_AMI_DEVICE_CLASS_ELECTRIC_VEHICLE (0x0400) +#define EMBER_AF_AMI_DEVICE_CLASS_ELECTRIC_VEHICLE_OFFSET (10) +#define EMBER_AF_AMI_DEVICE_CLASS_GENERATION_SYSTEMS (0x0800) +#define EMBER_AF_AMI_DEVICE_CLASS_GENERATION_SYSTEMS_OFFSET (11) +#define EMBER_AF_AMI_EVENT_CONTROL_RANDOMIZED_START_TIME (0x01) +#define EMBER_AF_AMI_EVENT_CONTROL_RANDOMIZED_END_TIME (0x02) +#define EMBER_AF_AMI_EVENT_CONTROL_RANDOMIZED_END_TIME_OFFSET (1) +#define EMBER_AF_AMI_CANCEL_CONTROL_TERMINATE_WITH_RANDOMIZATION (0x01) +#define EMBER_AF_AMI_METER_STATUS_CHECK_METER (0x01) +#define EMBER_AF_AMI_METER_STATUS_LOW_BATTERY (0x02) +#define EMBER_AF_AMI_METER_STATUS_LOW_BATTERY_OFFSET (1) +#define EMBER_AF_AMI_METER_STATUS_TAMPER_DETECT (0x04) +#define EMBER_AF_AMI_METER_STATUS_TAMPER_DETECT_OFFSET (2) +#define EMBER_AF_AMI_METER_STATUS_POWER_FAILURE (0x08) +#define EMBER_AF_AMI_METER_STATUS_POWER_FAILURE_OFFSET (3) +#define EMBER_AF_AMI_METER_STATUS_POWER_QUALITY (0x10) +#define EMBER_AF_AMI_METER_STATUS_POWER_QUALITY_OFFSET (4) +#define EMBER_AF_AMI_METER_STATUS_LEAK_DETECT (0x20) +#define EMBER_AF_AMI_METER_STATUS_LEAK_DETECT_OFFSET (5) +#define EMBER_AF_AMI_METER_STATUS_SERVICE_DISCONNECT_OPEN (0x40) +#define EMBER_AF_AMI_METER_STATUS_SERVICE_DISCONNECT_OPEN_OFFSET (6) +#define EMBER_AF_AMI_METER_STATUS_RESERVED (0x80) +#define EMBER_AF_AMI_METER_STATUS_RESERVED_OFFSET (7) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_CHECK_METER (0x01) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_LOW_BATTERY (0x02) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_LOW_BATTERY_OFFSET (1) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_TAMPER_DETECT (0x04) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_TAMPER_DETECT_OFFSET (2) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_POWER_FAILURE (0x08) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_POWER_FAILURE_OFFSET (3) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_POWER_QUALITY (0x10) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_POWER_QUALITY_OFFSET (4) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_LEAK_DETECT (0x20) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_LEAK_DETECT_OFFSET (5) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_SERVICE_DISCONNECT_OPEN (0x40) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_SERVICE_DISCONNECT_OPEN_OFFSET (6) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_RESERVED (0x80) +#define EMBER_AF_METERING_STATUS_ELECTRICITY_RESERVED_OFFSET (7) +#define EMBER_AF_METERING_STATUS_GAS_CHECK_METER (0x01) +#define EMBER_AF_METERING_STATUS_GAS_LOW_BATTERY (0x02) +#define EMBER_AF_METERING_STATUS_GAS_LOW_BATTERY_OFFSET (1) +#define EMBER_AF_METERING_STATUS_GAS_TAMPER_DETECT (0x04) +#define EMBER_AF_METERING_STATUS_GAS_TAMPER_DETECT_OFFSET (2) +#define EMBER_AF_METERING_STATUS_GAS_NOT_DEFINED (0x08) +#define EMBER_AF_METERING_STATUS_GAS_NOT_DEFINED_OFFSET (3) +#define EMBER_AF_METERING_STATUS_GAS_LOW_PRESSURE (0x10) +#define EMBER_AF_METERING_STATUS_GAS_LOW_PRESSURE_OFFSET (4) +#define EMBER_AF_METERING_STATUS_GAS_LEAK_DETECT (0x20) +#define EMBER_AF_METERING_STATUS_GAS_LEAK_DETECT_OFFSET (5) +#define EMBER_AF_METERING_STATUS_GAS_SERVICE_DISCONNECT (0x40) +#define EMBER_AF_METERING_STATUS_GAS_SERVICE_DISCONNECT_OFFSET (6) +#define EMBER_AF_METERING_STATUS_GAS_REVERSE_FLOW (0x80) +#define EMBER_AF_METERING_STATUS_GAS_REVERSE_FLOW_OFFSET (7) +#define EMBER_AF_METERING_STATUS_WATER_CHECK_METER (0x01) +#define EMBER_AF_METERING_STATUS_WATER_LOW_BATTERY (0x02) +#define EMBER_AF_METERING_STATUS_WATER_LOW_BATTERY_OFFSET (1) +#define EMBER_AF_METERING_STATUS_WATER_TAMPER_DETECT (0x04) +#define EMBER_AF_METERING_STATUS_WATER_TAMPER_DETECT_OFFSET (2) +#define EMBER_AF_METERING_STATUS_WATER_PIPE_EMPTY (0x08) +#define EMBER_AF_METERING_STATUS_WATER_PIPE_EMPTY_OFFSET (3) +#define EMBER_AF_METERING_STATUS_WATER_LOW_PRESSURE (0x10) +#define EMBER_AF_METERING_STATUS_WATER_LOW_PRESSURE_OFFSET (4) +#define EMBER_AF_METERING_STATUS_WATER_LEAK_DETECT (0x20) +#define EMBER_AF_METERING_STATUS_WATER_LEAK_DETECT_OFFSET (5) +#define EMBER_AF_METERING_STATUS_WATER_SERVICE_DISCONNECT (0x40) +#define EMBER_AF_METERING_STATUS_WATER_SERVICE_DISCONNECT_OFFSET (6) +#define EMBER_AF_METERING_STATUS_WATER_REVERSE_FLOW (0x80) +#define EMBER_AF_METERING_STATUS_WATER_REVERSE_FLOW_OFFSET (7) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_CHECK_METER (0x01) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_LOW_BATTERY (0x02) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_LOW_BATTERY_OFFSET (1) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_TAMPER_DETECT (0x04) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_TAMPER_DETECT_OFFSET (2) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_TEMPERATURE_SENSOR (0x08) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_TEMPERATURE_SENSOR_OFFSET (3) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_BURST_DETECT (0x10) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_BURST_DETECT_OFFSET (4) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_LEAK_DETECT (0x20) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_LEAK_DETECT_OFFSET (5) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_SERVICE_DISCONNECT (0x40) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_SERVICE_DISCONNECT_OFFSET (6) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_FLOW_SENSOR (0x80) +#define EMBER_AF_METERING_STATUS_HEAT_AND_COOLING_FLOW_SENSOR_OFFSET (7) +#define EMBER_AF_METERING_EXTENDED_STATUS_METER_COVER_REMOVED (0x0000000000000001) +#define EMBER_AF_METERING_EXTENDED_STATUS_STRONG_MAGNETIC_FIELD_DETECTED (0x0000000000000002) +#define EMBER_AF_METERING_EXTENDED_STATUS_STRONG_MAGNETIC_FIELD_DETECTED_OFFSET (1) +#define EMBER_AF_METERING_EXTENDED_STATUS_BATTERY_FAILURE (0x0000000000000004) +#define EMBER_AF_METERING_EXTENDED_STATUS_BATTERY_FAILURE_OFFSET (2) +#define EMBER_AF_METERING_EXTENDED_STATUS_PROGRAM_MEMORY_ERROR (0x0000000000000008) +#define EMBER_AF_METERING_EXTENDED_STATUS_PROGRAM_MEMORY_ERROR_OFFSET (3) +#define EMBER_AF_METERING_EXTENDED_STATUS_RAM_ERROR (0x0000000000000010) +#define EMBER_AF_METERING_EXTENDED_STATUS_RAM_ERROR_OFFSET (4) +#define EMBER_AF_METERING_EXTENDED_STATUS_NV_MEMORY_ERROR (0x0000000000000020) +#define EMBER_AF_METERING_EXTENDED_STATUS_NV_MEMORY_ERROR_OFFSET (5) +#define EMBER_AF_METERING_EXTENDED_STATUS_MEASUREMENT_SYSTEM_ERROR (0x0000000000000040) +#define EMBER_AF_METERING_EXTENDED_STATUS_MEASUREMENT_SYSTEM_ERROR_OFFSET (6) +#define EMBER_AF_METERING_EXTENDED_STATUS_WATCHDOG_ERROR (0x0000000000000080) +#define EMBER_AF_METERING_EXTENDED_STATUS_WATCHDOG_ERROR_OFFSET (7) +#define EMBER_AF_METERING_EXTENDED_STATUS_SUPPLY_DISCONNECT_FAILURE (0x0000000000000100) +#define EMBER_AF_METERING_EXTENDED_STATUS_SUPPLY_DISCONNECT_FAILURE_OFFSET (8) +#define EMBER_AF_METERING_EXTENDED_STATUS_SUPPLY_CONNECT_FAILURE (0x0000000000000200) +#define EMBER_AF_METERING_EXTENDED_STATUS_SUPPLY_CONNECT_FAILURE_OFFSET (9) +#define EMBER_AF_METERING_EXTENDED_STATUS_MEASUREMENT_SW_CHANGED_TAMPERED (0x0000000000000400) +#define EMBER_AF_METERING_EXTENDED_STATUS_MEASUREMENT_SW_CHANGED_TAMPERED_OFFSET (10) +#define EMBER_AF_METERING_EXTENDED_STATUS_CLOCK_INVALID (0x0000000000000800) +#define EMBER_AF_METERING_EXTENDED_STATUS_CLOCK_INVALID_OFFSET (11) +#define EMBER_AF_METERING_EXTENDED_STATUS_TEMPERATURE_EXCEEDED (0x0000000000001000) +#define EMBER_AF_METERING_EXTENDED_STATUS_TEMPERATURE_EXCEEDED_OFFSET (12) +#define EMBER_AF_METERING_EXTENDED_STATUS_MOISTURE_DETECTED (0x0000000000002000) +#define EMBER_AF_METERING_EXTENDED_STATUS_MOISTURE_DETECTED_OFFSET (13) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_BATTERY_COVER_REMOVED (0x0000000001000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_BATTERY_COVER_REMOVED_OFFSET (24) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_TILT_TAMPER (0x0000000002000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_TILT_TAMPER_OFFSET (25) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_EXCESS_FLOW (0x0000000004000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_GAS_METER_EXCESS_FLOW_OFFSET (26) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_LIMIT_THRESHOLD_EXCEEDED (0x0000000008000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_LIMIT_THRESHOLD_EXCEEDED_OFFSET (27) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_UNDER_VOLTAGE (0x0000000010000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_UNDER_VOLTAGE_OFFSET (28) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_OVER_VOLTAGE (0x0000000020000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_OVER_VOLTAGE_OFFSET (29) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_POWER (0x0000000040000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_POWER_OFFSET (30) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_VOLTAGE (0x0000000080000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_VOLTAGE_OFFSET (31) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_REMOTE_LOAD_CONTROL (0x00000000C0000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_REMOTE_LOAD_CONTROL_OFFSET (30) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_BY_OTHER_REMOTE_COMMAND (0x0000000100000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_BY_OTHER_REMOTE_COMMAND_OFFSET (32) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT (0x0000000140000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT_OFFSET (30) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_OTHER (0x0000000180000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_OTHER_OFFSET (31) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_BI_DIRECTIONAL_OPERATION (0x0000000400000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_BI_DIRECTIONAL_OPERATION_OFFSET (34) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_ACTIVE_POWER_RECEIVED (0x0000000800000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_ACTIVE_POWER_RECEIVED_OFFSET (35) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_MODE_OF_OPERATION (0x0000001000000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_MODE_OF_OPERATION_OFFSET (36) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_NEW_OTA_FIRMWARE (0x00000001) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CBKE_UPDATE_REQUEST (0x00000002) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CBKE_UPDATE_REQUEST_OFFSET (1) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_TIME_SYNC (0x00000004) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_TIME_SYNC_OFFSET (2) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_STAY_AWAKE_REQUEST_HAN (0x00000010) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_STAY_AWAKE_REQUEST_HAN_OFFSET (4) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_STAY_AWAKE_REQUEST_WAN (0x00000020) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_STAY_AWAKE_REQUEST_WAN_OFFSET (5) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET (0x000001C0) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET_OFFSET (6) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET (0x00000E00) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET_OFFSET (9) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER (0x00001000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER_OFFSET (12) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_METERING_CLUSTER (0x00002000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_METERING_CLUSTER_OFFSET (13) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER (0x00004000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER_OFFSET (14) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_NETWORK_KEY_ACTIVE (0x00008000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_NETWORK_KEY_ACTIVE_OFFSET (15) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_DISPLAY_MESSAGE (0x00010000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_DISPLAY_MESSAGE_OFFSET (16) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CANCEL_ALL_MESSAGES (0x00020000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CANCEL_ALL_MESSAGES_OFFSET (17) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CHANGE_SUPPLY (0x00040000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CHANGE_SUPPLY_OFFSET (18) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_LOCAL_CHANGE_SUPPLY (0x00080000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_LOCAL_CHANGE_SUPPLY_OFFSET (19) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_SET_UNCONTROLLED_FLOW_THRESHOLD (0x00100000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_SET_UNCONTROLLED_FLOW_THRESHOLD_OFFSET (20) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_TUNNEL_MESSAGE_PENDING (0x00200000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_TUNNEL_MESSAGE_PENDING_OFFSET (21) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_GET_SNAPSHOT (0x00400000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_GET_SNAPSHOT_OFFSET (22) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_GET_SAMPLED_DATA (0x00800000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_GET_SAMPLED_DATA_OFFSET (23) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE (0x01000000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE_OFFSET (24) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_ENERGY_SCAN_PENDING (0x02000000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_ENERGY_SCAN_PENDING_OFFSET (25) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CHANNEL_CHANGE_PENDING (0x04000000) +#define EMBER_AF_FUNCTIONAL_NOTIFICATION_FLAGS_CHANNEL_CHANGE_PENDING_OFFSET (26) +#define EMBER_AF_SNAPSHOT_CAUSE_GENERAL (0x00000001) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_BILLING_PERIOD (0x00000002) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_BILLING_PERIOD_OFFSET (1) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_BLOCK_PERIOD (0x00000004) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_BLOCK_PERIOD_OFFSET (2) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_TARIFF_INFORMATION (0x00000008) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_TARIFF_INFORMATION_OFFSET (3) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_PRICE_MATRIX (0x00000010) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_PRICE_MATRIX_OFFSET (4) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_BLOCK_THRESHOLDS (0x00000020) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_BLOCK_THRESHOLDS_OFFSET (5) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CV (0x00000040) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CV_OFFSET (6) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CF (0x00000080) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CF_OFFSET (7) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CALENDAR (0x00000100) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_CALENDAR_OFFSET (8) +#define EMBER_AF_SNAPSHOT_CAUSE_CRITICAL_PEAK_PRICING (0x00000200) +#define EMBER_AF_SNAPSHOT_CAUSE_CRITICAL_PEAK_PRICING_OFFSET (9) +#define EMBER_AF_SNAPSHOT_CAUSE_MANUALLY_TRIGGERED_FROM_CLIENT (0x00000400) +#define EMBER_AF_SNAPSHOT_CAUSE_MANUALLY_TRIGGERED_FROM_CLIENT_OFFSET (10) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_RESOLVE_PERIOD (0x00000800) +#define EMBER_AF_SNAPSHOT_CAUSE_END_OF_RESOLVE_PERIOD_OFFSET (11) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_TENANCY (0x00001000) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_TENANCY_OFFSET (12) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_SUPPLIER (0x00002000) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_SUPPLIER_OFFSET (13) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_MODE (0x00004000) +#define EMBER_AF_SNAPSHOT_CAUSE_CHANGE_OF_MODE_OFFSET (14) +#define EMBER_AF_SNAPSHOT_CAUSE_DEBT_PAYMENT (0x00008000) +#define EMBER_AF_SNAPSHOT_CAUSE_DEBT_PAYMENT_OFFSET (15) +#define EMBER_AF_SNAPSHOT_CAUSE_SCHEDULED_SNAPSHOT (0x00010000) +#define EMBER_AF_SNAPSHOT_CAUSE_SCHEDULED_SNAPSHOT_OFFSET (16) +#define EMBER_AF_SNAPSHOT_CAUSE_OTA_FIRMWARE_DOWNLOAD (0x00020000) +#define EMBER_AF_SNAPSHOT_CAUSE_OTA_FIRMWARE_DOWNLOAD_OFFSET (17) +#define EMBER_AF_SUPPLY_CONTROL_BITS_ACKNOWLEDGE_REQUIRED (0x01) +#define EMBER_AF_MESSAGING_CONTROL_MASK_TRANS_MECHANISM (0x03) +#define EMBER_AF_MESSAGING_CONTROL_MASK_MESSAGE_URGENCY (0x0C) +#define EMBER_AF_MESSAGING_CONTROL_MASK_MESSAGE_URGENCY_OFFSET (2) +#define EMBER_AF_MESSAGING_CONTROL_MASK_ENHANCED_CONFIRMATION_REQUEST (0x20) +#define EMBER_AF_MESSAGING_CONTROL_MASK_ENHANCED_CONFIRMATION_REQUEST_OFFSET (5) +#define EMBER_AF_MESSAGING_CONTROL_MASK_MESSAGE_CONFIRMATION (0x80) +#define EMBER_AF_MESSAGING_CONTROL_MASK_MESSAGE_CONFIRMATION_OFFSET (7) +#define EMBER_AF_MESSAGING_EXTENDED_CONTROL_MASK_MESSAGE_CONFIRMATION_STATUS (0x01) +#define EMBER_AF_MESSAGING_CONFIRMATION_CONTROL_NO_RETURNED (0x01) +#define EMBER_AF_MESSAGING_CONFIRMATION_CONTROL_YES_RETURNED (0x02) +#define EMBER_AF_MESSAGING_CONFIRMATION_CONTROL_YES_RETURNED_OFFSET (1) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_DISCONNECTION_ENABLED (0x0001) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_PREPAYMENT_ENABLED (0x0002) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_PREPAYMENT_ENABLED_OFFSET (1) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CREDIT_MANAGEMENT_ENABLED (0x0004) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CREDIT_MANAGEMENT_ENABLED_OFFSET (2) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CREDIT_DISPLAY_ENABLED (0x0010) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CREDIT_DISPLAY_ENABLED_OFFSET (4) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_ACCOUNT_BASE (0x0040) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_ACCOUNT_BASE_OFFSET (6) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CONTACTOR_FITTED (0x0080) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_CONTACTOR_FITTED_OFFSET (7) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_STANDING_CHARGE_CONFIGURATION (0x0100) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_STANDING_CHARGE_CONFIGURATION_OFFSET (8) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_EMERGENCY_STANDING_CHARGE_CONFIGURATION (0x0200) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_EMERGENCY_STANDING_CHARGE_CONFIGURATION_OFFSET (9) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_DEBT_CONFIGURATION (0x0400) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_DEBT_CONFIGURATION_OFFSET (10) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_EMERGENCY_DEBT_CONFIGURATION (0x0800) +#define EMBER_AF_PAYMENT_CONTROL_CONFIGURATION_EMERGENCY_DEBT_CONFIGURATION_OFFSET (11) +#define EMBER_AF_CREDIT_STATUS_CREDIT_OK (0x01) +#define EMBER_AF_CREDIT_STATUS_LOW_CREDIT (0x02) +#define EMBER_AF_CREDIT_STATUS_LOW_CREDIT_OFFSET (1) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_ENABLED (0x04) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_ENABLED_OFFSET (2) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_AVAILABLE (0x08) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_AVAILABLE_OFFSET (3) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_SELECTED (0x10) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_SELECTED_OFFSET (4) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_IN_USE (0x20) +#define EMBER_AF_CREDIT_STATUS_EMERGENCY_CREDIT_IN_USE_OFFSET (5) +#define EMBER_AF_CREDIT_STATUS_CREDIT_EXHAUSTED (0x40) +#define EMBER_AF_CREDIT_STATUS_CREDIT_EXHAUSTED_OFFSET (6) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_LOW_CREDIT_WARNING (0x0001) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_ERROR (0x0002) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_ERROR_OFFSET (1) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_ALREADY_USED (0x0004) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_ALREADY_USED_OFFSET (2) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_INVALID (0x0008) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_TOP_UP_CODE_INVALID_OFFSET (3) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_FRIENDLY_CREDIT_IN_USE (0x0010) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_FRIENDLY_CREDIT_IN_USE_OFFSET (4) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_FRIENDLY_CREDIT_PERIOD_END_WARNING (0x0020) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_FRIENDLY_CREDIT_PERIOD_END_WARNING_OFFSET (5) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_EC_AVAILABLE (0x0040) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_EC_AVAILABLE_OFFSET (6) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_UNAUTHORISED_ENERGY_USE (0x0080) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_UNAUTHORISED_ENERGY_USE_OFFSET (7) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_CREDIT (0x0100) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_CREDIT_OFFSET (8) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_TAMPER (0x0200) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_TAMPER_OFFSET (9) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_HES (0x0400) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_DISCONNECTED_SUPPLY_DUE_TO_HES_OFFSET (10) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_PHYSICAL_ATTACK (0x0800) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_PHYSICAL_ATTACK_OFFSET (11) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_ELECTRONIC_ATTACK (0x1000) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_ELECTRONIC_ATTACK_OFFSET (12) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_MANUFACTURE_ALARM_CODE_A (0x2000) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_MANUFACTURE_ALARM_CODE_A_OFFSET (13) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_MANUFACTURE_ALARM_CODE_B (0x4000) +#define EMBER_AF_PREPAYMENT_ALARM_STATUS_MANUFACTURE_ALARM_CODE_B_OFFSET (14) +#define EMBER_AF_ORIGINATOR_ID_SUPPLY_CONTROL_BITS_ACKNOWLEDGE_REQUIRED (0x01) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_GENERAL (0x00000001) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_TARIFF_INFORMATION (0x00000008) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_TARIFF_INFORMATION_OFFSET (3) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_PRICE_MATRIX (0x00000010) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_PRICE_MATRIX_OFFSET (4) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_MANUALLY_TRIGGERED_FROM_CLIENT (0x00000400) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_MANUALLY_TRIGGERED_FROM_CLIENT_OFFSET (10) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_TENANCY (0x00001000) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_TENANCY_OFFSET (12) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_SUPPLIER (0x00002000) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_SUPPLIER_OFFSET (13) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_METER_MODE (0x00004000) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_CHANGE_OF_METER_MODE_OFFSET (14) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_TOP_UP_ADDITION (0x00040000) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_TOP_UP_ADDITION_OFFSET (18) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_DEBT_CREDIT_ADDITION (0x00080000) +#define EMBER_AF_PREPAY_SNAPSHOT_PAYLOAD_CAUSE_DEBT_CREDIT_ADDITION_OFFSET (19) +#define EMBER_AF_FRIENDLY_CREDIT_FRIENDLY_CREDIT_ENABLED (0x01) +#define EMBER_AF_LOAD_CONTROL_STATE_RELAY_OPEN_OR_CONSUMPTION_INTERUPTED (0x01) +#define EMBER_AF_LOAD_CONTROL_STATE_EVENT_IN_PROGRESS (0x02) +#define EMBER_AF_LOAD_CONTROL_STATE_EVENT_IN_PROGRESS_OFFSET (1) +#define EMBER_AF_LOAD_CONTROL_STATE_POWER_STABILIZING (0x04) +#define EMBER_AF_LOAD_CONTROL_STATE_POWER_STABILIZING_OFFSET (2) +#define EMBER_AF_LOAD_CONTROL_STATE_OTHER_LOAD_REDUCTION (0x08) +#define EMBER_AF_LOAD_CONTROL_STATE_OTHER_LOAD_REDUCTION_OFFSET (3) +#define EMBER_AF_LOAD_CONTROL_STATE_CURRENT_FLOW_OR_CONSUMING_COMMODITY (0x10) +#define EMBER_AF_LOAD_CONTROL_STATE_CURRENT_FLOW_OR_CONSUMING_COMMODITY_OFFSET (4) +#define EMBER_AF_LOAD_CONTROL_STATE_LOAD_CALL (0x20) +#define EMBER_AF_LOAD_CONTROL_STATE_LOAD_CALL_OFFSET (5) +#define EMBER_AF_CURRENT_EVENT_STATUS_RANDOMIZED_START_TIME (0x01) +#define EMBER_AF_CURRENT_EVENT_STATUS_RANDOMIZED_DURATION (0x02) +#define EMBER_AF_CURRENT_EVENT_STATUS_RANDOMIZED_DURATION_OFFSET (1) +#define EMBER_AF_CURRENT_EVENT_STATUS_EXTENDED_BITS_PRESENT (0x04) +#define EMBER_AF_CURRENT_EVENT_STATUS_EXTENDED_BITS_PRESENT_OFFSET (2) +#define EMBER_AF_CURRENT_EVENT_STATUS_EVENT_ACTIVE (0x08) +#define EMBER_AF_CURRENT_EVENT_STATUS_EVENT_ACTIVE_OFFSET (3) +#define EMBER_AF_CURRENT_EVENT_STATUS_DEVICE_PARTICIPATING_IN_EVENT (0x10) +#define EMBER_AF_CURRENT_EVENT_STATUS_DEVICE_PARTICIPATING_IN_EVENT_OFFSET (4) +#define EMBER_AF_CURRENT_EVENT_STATUS_REDUCING_LOAD (0x20) +#define EMBER_AF_CURRENT_EVENT_STATUS_REDUCING_LOAD_OFFSET (5) +#define EMBER_AF_CURRENT_EVENT_STATUS_ON_AT_END_OF_EVENT (0x40) +#define EMBER_AF_CURRENT_EVENT_STATUS_ON_AT_END_OF_EVENT_OFFSET (6) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH1 (0x01) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH2 (0x02) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH2_OFFSET (1) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH3 (0x04) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH3_OFFSET (2) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH4 (0x08) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH4_OFFSET (3) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH5 (0x10) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH5_OFFSET (4) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH6 (0x20) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH6_OFFSET (5) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH7 (0x40) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH7_OFFSET (6) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH8 (0x80) +#define EMBER_AF_AUXILIARY_LOAD_SWITCH_STATE_AUXILIARY_SWITCH8_OFFSET (7) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_PRE_SNAPSHOTS (0x00000001) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_POST_SNAPSHOTS (0x00000002) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_POST_SNAPSHOTS_OFFSET (1) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_CREDIT_REGISTER (0x00000004) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_CREDIT_REGISTER_OFFSET (2) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_DEBIT_REGISTER (0x00000008) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_DEBIT_REGISTER_OFFSET (3) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_BILLING_PERIOD (0x00000010) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_RESET_BILLING_PERIOD_OFFSET (4) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_TARIFF_PLAN (0x00000020) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_TARIFF_PLAN_OFFSET (5) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_STANDING_CHARGE (0x00000040) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_STANDING_CHARGE_OFFSET (6) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_BLOCK_HISTORICAL_LOAD_PROFILE_INFORMATION (0x00000080) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_BLOCK_HISTORICAL_LOAD_PROFILE_INFORMATION_OFFSET (7) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_HISTORICAL_LOAD_PROFILE_INFORMATION (0x00000100) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_HISTORICAL_LOAD_PROFILE_INFORMATION_OFFSET (8) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_IHD_DATA_CONSUMER (0x00000200) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_IHD_DATA_CONSUMER_OFFSET (9) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_IHD_DATA_SUPPLIER (0x00000400) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_IHD_DATA_SUPPLIER_OFFSET (10) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_METER_CONNECTOR_STATE_ON_OFF_ARMED (0x00001800) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_METER_CONNECTOR_STATE_ON_OFF_ARMED_OFFSET (11) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_TRANSACTION_LOG (0x00002000) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_TRANSACTION_LOG_OFFSET (13) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_PREPAYMENT_LOG (0x00004000) +#define EMBER_AF_PROPOSED_CHANGE_CONTROL_CLEAR_PREPAYMENT_LOG_OFFSET (14) +#define EMBER_AF_EVENT_CONFIGURATION_LOG_ACTION (0x07) +#define EMBER_AF_EVENT_CONFIGURATION_PUSH_EVENT_TO_W_A_N (0x08) +#define EMBER_AF_EVENT_CONFIGURATION_PUSH_EVENT_TO_W_A_N_OFFSET (3) +#define EMBER_AF_EVENT_CONFIGURATION_PUSH_EVENT_TO_H_A_N (0x10) +#define EMBER_AF_EVENT_CONFIGURATION_PUSH_EVENT_TO_H_A_N_OFFSET (4) +#define EMBER_AF_EVENT_CONFIGURATION_RAISE_ALARM_ZIG_BEE (0x20) +#define EMBER_AF_EVENT_CONFIGURATION_RAISE_ALARM_ZIG_BEE_OFFSET (5) +#define EMBER_AF_EVENT_CONFIGURATION_RAISE_ALARM_PHYSICAL (0x40) +#define EMBER_AF_EVENT_CONFIGURATION_RAISE_ALARM_PHYSICAL_OFFSET (6) +#define EMBER_AF_EVENT_CONTROL_LOG_ID_LOG_ID (0x0F) +#define EMBER_AF_EVENT_CONTROL_LOG_ID_EVENT_CONTROL (0xF0) +#define EMBER_AF_EVENT_CONTROL_LOG_ID_EVENT_CONTROL_OFFSET (4) +#define EMBER_AF_EVENT_ACTION_CONTROL_REPORT_EVENT_TO_H_A_N_DEVICES (0x01) +#define EMBER_AF_EVENT_ACTION_CONTROL_REPORT_EVENT_TO_W_A_N (0x02) +#define EMBER_AF_EVENT_ACTION_CONTROL_REPORT_EVENT_TO_W_A_N_OFFSET (1) +#define EMBER_AF_NUMBER_OF_EVENTS_LOG_PAYLOAD_CONTROL_LOG_PAYLOAD_CONTROL (0x0F) +#define EMBER_AF_NUMBER_OF_EVENTS_LOG_PAYLOAD_CONTROL_NUMBER_OF_EVENTS (0xF0) +#define EMBER_AF_NUMBER_OF_EVENTS_LOG_PAYLOAD_CONTROL_NUMBER_OF_EVENTS_OFFSET (4) +#define EMBER_AF_CLEARED_EVENTS_LOGS_ALL_LOGS_CLEARED (0x01) +#define EMBER_AF_CLEARED_EVENTS_LOGS_TAMPER_LOG_CLEARED (0x02) +#define EMBER_AF_CLEARED_EVENTS_LOGS_TAMPER_LOG_CLEARED_OFFSET (1) +#define EMBER_AF_CLEARED_EVENTS_LOGS_FAULT_LOG_CLEARED (0x04) +#define EMBER_AF_CLEARED_EVENTS_LOGS_FAULT_LOG_CLEARED_OFFSET (2) +#define EMBER_AF_CLEARED_EVENTS_LOGS_GENERAL_EVENT_LOG_CLEARED (0x08) +#define EMBER_AF_CLEARED_EVENTS_LOGS_GENERAL_EVENT_LOG_CLEARED_OFFSET (3) +#define EMBER_AF_CLEARED_EVENTS_LOGS_SECURITY_EVENT_LOG_CLEARED (0x10) +#define EMBER_AF_CLEARED_EVENTS_LOGS_SECURITY_EVENT_LOG_CLEARED_OFFSET (4) +#define EMBER_AF_CLEARED_EVENTS_LOGS_NETWORK_EVENT_LOG_CLEARED (0x20) +#define EMBER_AF_CLEARED_EVENTS_LOGS_NETWORK_EVENT_LOG_CLEARED_OFFSET (5) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL0 (0x00000001) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL1 (0x00000002) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL1_OFFSET (1) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL2 (0x00000004) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL2_OFFSET (2) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL3 (0x00000008) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL3_OFFSET (3) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL4 (0x00000010) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL4_OFFSET (4) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL5 (0x00000020) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL5_OFFSET (5) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL6 (0x00000040) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL6_OFFSET (6) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL7 (0x00000080) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL7_OFFSET (7) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL8 (0x00000100) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL8_OFFSET (8) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL9 (0x00000200) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL9_OFFSET (9) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL10 (0x00000400) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL10_OFFSET (10) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL11 (0x00000800) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL11_OFFSET (11) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL12 (0x00001000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL12_OFFSET (12) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL13 (0x00002000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL13_OFFSET (13) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL14 (0x00004000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL14_OFFSET (14) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL15 (0x00008000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL15_OFFSET (15) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL16 (0x00010000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL16_OFFSET (16) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL17 (0x00020000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL17_OFFSET (17) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL18 (0x00040000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL18_OFFSET (18) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL19 (0x00080000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL19_OFFSET (19) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL20 (0x00100000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL20_OFFSET (20) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL21 (0x00200000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL21_OFFSET (21) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL22 (0x00400000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL22_OFFSET (22) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL23 (0x00800000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL23_OFFSET (23) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL24 (0x01000000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL24_OFFSET (24) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL25 (0x02000000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL25_OFFSET (25) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL26 (0x04000000) +#define EMBER_AF_CHANNEL_MASK915_CHANNEL26_OFFSET (26) +#define EMBER_AF_CHANNEL_MASK_PAGE (0xF8000000) +#define EMBER_AF_CHANNEL_MASK_PAGE_OFFSET (27) +#define EMBER_AF_SCENES_COPY_MODE_COPY_ALL_SCENES (0x01) +#define EMBER_AF_ON_OFF_CONTROL_ACCEPT_ONLY_WHEN_ON (0x01) +#define EMBER_AF_COLOR_CAPABILITIES_HUE_SATURATION_SUPPORTED (0x0001) +#define EMBER_AF_COLOR_CAPABILITIES_ENHANCED_HUE_SUPPORTED (0x0002) +#define EMBER_AF_COLOR_CAPABILITIES_ENHANCED_HUE_SUPPORTED_OFFSET (1) +#define EMBER_AF_COLOR_CAPABILITIES_COLOR_LOOP_SUPPORTED (0x0004) +#define EMBER_AF_COLOR_CAPABILITIES_COLOR_LOOP_SUPPORTED_OFFSET (2) +#define EMBER_AF_COLOR_CAPABILITIES_X_Y_ATTRIBUTES_SUPPORTED (0x0008) +#define EMBER_AF_COLOR_CAPABILITIES_X_Y_ATTRIBUTES_SUPPORTED_OFFSET (3) +#define EMBER_AF_COLOR_CAPABILITIES_COLOR_TEMPERATURE_SUPPORTED (0x0010) +#define EMBER_AF_COLOR_CAPABILITIES_COLOR_TEMPERATURE_SUPPORTED_OFFSET (4) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_ACTION (0x01) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_DIRECTION (0x02) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_DIRECTION_OFFSET (1) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_TIME (0x04) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_TIME_OFFSET (2) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_START_HUE (0x08) +#define EMBER_AF_COLOR_LOOP_UPDATE_FLAGS_UPDATE_START_HUE_OFFSET (3) +#define EMBER_AF_ZIGBEE_INFORMATION_LOGICAL_TYPE (0x03) +#define EMBER_AF_ZIGBEE_INFORMATION_RX_ON_WHEN_IDLE (0x04) +#define EMBER_AF_ZIGBEE_INFORMATION_RX_ON_WHEN_IDLE_OFFSET (2) +#define EMBER_AF_ZLL_INFORMATION_FACTORY_NEW (0x01) +#define EMBER_AF_ZLL_INFORMATION_ADDRESS_ASSIGNMENT (0x02) +#define EMBER_AF_ZLL_INFORMATION_ADDRESS_ASSIGNMENT_OFFSET (1) +#define EMBER_AF_ZLL_INFORMATION_TOUCH_LINK_INITIATOR (0x10) +#define EMBER_AF_ZLL_INFORMATION_TOUCH_LINK_INITIATOR_OFFSET (4) +#define EMBER_AF_ZLL_INFORMATION_TOUCH_LINK_PRIORITY_REQUEST (0x20) +#define EMBER_AF_ZLL_INFORMATION_TOUCH_LINK_PRIORITY_REQUEST_OFFSET (5) +#define EMBER_AF_ZLL_INFORMATION_PROFILE_INTEROP (0x80) +#define EMBER_AF_ZLL_INFORMATION_PROFILE_INTEROP_OFFSET (7) +#define EMBER_AF_KEY_BITMASK_DEVELOPMENT (0x0001) +#define EMBER_AF_KEY_BITMASK_MASTER (0x0010) +#define EMBER_AF_KEY_BITMASK_MASTER_OFFSET (4) +#define EMBER_AF_KEY_BITMASK_CERTIFICATION (0x8000) +#define EMBER_AF_KEY_BITMASK_CERTIFICATION_OFFSET (15) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GP_FEATURE (0x000001) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_DIRECT_COMMUNICATION (0x000002) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_DIRECT_COMMUNICATION_OFFSET (1) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_DERIVED_GROUPCAST_COMMUNICATION (0x000004) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_DERIVED_GROUPCAST_COMMUNICATION_OFFSET (2) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PRE_COMMISSIONED_GROUPCAST_COMMUNICATION (0x000008) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PRE_COMMISSIONED_GROUPCAST_COMMUNICATION_OFFSET (3) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_FULL_UNICAST_COMMUNICATION (0x000010) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_FULL_UNICAST_COMMUNICATION_OFFSET (4) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_LIGHTWEIGHT_UNICAST_COMMUNICATION (0x000020) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_LIGHTWEIGHT_UNICAST_COMMUNICATION_OFFSET (5) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXIMITY_BIDIRECTIONAL_COMMUNICATION (0x000040) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXIMITY_BIDIRECTIONAL_COMMUNICATION_OFFSET (6) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MULTIHOP_BIDIRECTIONAL_COMMUNICATION (0x000080) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MULTIHOP_BIDIRECTIONAL_COMMUNICATION_OFFSET (7) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXY_TABLE_MAINTAINANCE (0x000100) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXY_TABLE_MAINTAINANCE_OFFSET (8) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXIMITY_COMMUNICATION (0x000200) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_PROXIMITY_COMMUNICATION_OFFSET (9) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MULTIHOP_COMMUNICATION (0x000400) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MULTIHOP_COMMUNICATION_OFFSET (10) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_CT_BASED_COMMISSIONING (0x000800) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_CT_BASED_COMMISSIONING_OFFSET (11) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MAINTAINANCE_GPDF (0x001000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_MAINTAINANCE_GPDF_OFFSET (12) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL0_IN_OPERATION (0x002000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL0_IN_OPERATION_OFFSET (13) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL1_IN_OPERATION (0x004000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL1_IN_OPERATION_OFFSET (14) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL2_IN_OPERATION (0x008000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL2_IN_OPERATION_OFFSET (15) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL3_IN_OPERATION (0x010000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_SECURITY_LEVEL3_IN_OPERATION_OFFSET (16) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_SINK_TABLE_BASED_GROUPCAST_FORWARDING (0x020000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_SINK_TABLE_BASED_GROUPCAST_FORWARDING_OFFSET (17) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_TRANSLATION_TABLE (0x040000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_TRANSLATION_TABLE_OFFSET (18) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_IEEE_ADDRESS (0x080000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_GPD_IEEE_ADDRESS_OFFSET (19) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_COMPACT_ATTRIBUTE_REPORTING (0x100000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_COMPACT_ATTRIBUTE_REPORTING_OFFSET (20) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_RESERVED (0xE00000) +#define EMBER_AF_GP_GPS_FUNCTIONALITY_RESERVED_OFFSET (21) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_APPLICATION_ID (0x00000007) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ENTRY_ACTIVE (0x00000008) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ENTRY_ACTIVE_OFFSET (3) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ENTRY_VALID (0x00000010) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ENTRY_VALID_OFFSET (4) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_SEQUENCE_NUMBER_CAP (0x00000020) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_SEQUENCE_NUMBER_CAP_OFFSET (5) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_LIGHTWEIGHT_UNICAST_GPS (0x00000040) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_LIGHTWEIGHT_UNICAST_GPS_OFFSET (6) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_DERIVED_GROUP_GPS (0x00000080) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_DERIVED_GROUP_GPS_OFFSET (7) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_COMMISIONED_GROUP_GPS (0x00000100) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_COMMISIONED_GROUP_GPS_OFFSET (8) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_FIRST_TO_FORWARD (0x00000200) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_FIRST_TO_FORWARD_OFFSET (9) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_IN_RANGE (0x00000400) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_IN_RANGE_OFFSET (10) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_GPD_FIXED (0x00000800) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_GPD_FIXED_OFFSET (11) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_HAS_ALL_UNICAST_ROUTES (0x00001000) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_HAS_ALL_UNICAST_ROUTES_OFFSET (12) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ASSIGNED_ALIAS (0x00002000) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_ASSIGNED_ALIAS_OFFSET (13) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_SECURITY_USE (0x00004000) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_SECURITY_USE_OFFSET (14) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_EXTENSION (0x00008000) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_EXTENSION_OFFSET (15) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_FULL_UNICAST_GPS (0x00010000) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_OPTIONS_FULL_UNICAST_GPS_OFFSET (16) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_LEVEL (0x03) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_KEY_TYPE (0x1C) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_KEY_TYPE_OFFSET (2) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_SECURITY_OPTIONS_RESERVED (0xE0) +#define EMBER_AF_GP_PROXY_TABLE_ENTRY_SECURITY_OPTIONS_RESERVED_OFFSET (5) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_MAC_SEQ_NUM_CAP (0x01) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_RX_ON_CAP (0x02) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_RX_ON_CAP_OFFSET (1) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_APPLICATION_INFORMATION_PRESENT (0x04) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_APPLICATION_INFORMATION_PRESENT_OFFSET (2) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_RESERVED (0x08) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_RESERVED_OFFSET (3) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_PAN_ID_REQUEST (0x10) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_PAN_ID_REQUEST_OFFSET (4) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_GP_SECURITY_KEY_REQUEST (0x20) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_GP_SECURITY_KEY_REQUEST_OFFSET (5) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_FIXED_LOCATION (0x40) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_FIXED_LOCATION_OFFSET (6) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_EXTENDED_OPTIONS_FIELD (0x80) +#define EMBER_AF_GP_GPD_COMMISSIONING_OPTIONS_EXTENDED_OPTIONS_FIELD_OFFSET (7) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_SECURITY_LEVEL_CAPABILITIES (0x03) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_KEY_TYPE (0x1C) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_KEY_TYPE_OFFSET (2) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_KEY_PRESENT (0x20) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_KEY_PRESENT_OFFSET (5) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_KEY_ENCRYPTION (0x40) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_KEY_ENCRYPTION_OFFSET (6) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_OUTGOING_COUNTER_PRESENT (0x80) +#define EMBER_AF_GP_GPD_COMMISSIONING_EXTENDED_OPTIONS_GPD_OUTGOING_COUNTER_PRESENT_OFFSET (7) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_PAN_ID_PRESENT (0x01) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_GPD_SECURITY_KEY_PRESENT (0x02) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_GPD_SECURITY_KEY_PRESENT_OFFSET (1) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_GPDKEY_ENCRYPTION (0x04) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_GPDKEY_ENCRYPTION_OFFSET (2) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_SECURITY_LEVEL (0x18) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_SECURITY_LEVEL_OFFSET (3) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_KEY_TYPE (0xE0) +#define EMBER_AF_GP_GPD_COMMISSIONING_REPLY_OPTIONS_KEY_TYPE_OFFSET (5) +#define EMBER_AF_GP_NOTIFICATION_OPTION_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_UNICAST (0x0008) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_UNICAST_OFFSET (3) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_DERIVED_GROUP (0x0010) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_DERIVED_GROUP_OFFSET (4) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_COMMISSIONED_GROUP (0x0020) +#define EMBER_AF_GP_NOTIFICATION_OPTION_ALSO_COMMISSIONED_GROUP_OFFSET (5) +#define EMBER_AF_GP_NOTIFICATION_OPTION_SECURITY_LEVEL (0x00C0) +#define EMBER_AF_GP_NOTIFICATION_OPTION_SECURITY_LEVEL_OFFSET (6) +#define EMBER_AF_GP_NOTIFICATION_OPTION_SECURITY_KEY_TYPE (0x0700) +#define EMBER_AF_GP_NOTIFICATION_OPTION_SECURITY_KEY_TYPE_OFFSET (8) +#define EMBER_AF_GP_NOTIFICATION_OPTION_RX_AFTER_TX (0x0800) +#define EMBER_AF_GP_NOTIFICATION_OPTION_RX_AFTER_TX_OFFSET (11) +#define EMBER_AF_GP_NOTIFICATION_OPTION_GP_TX_QUEUE_FULL (0x1000) +#define EMBER_AF_GP_NOTIFICATION_OPTION_GP_TX_QUEUE_FULL_OFFSET (12) +#define EMBER_AF_GP_NOTIFICATION_OPTION_BIDIRECTIONAL_CAPABILITY (0x2000) +#define EMBER_AF_GP_NOTIFICATION_OPTION_BIDIRECTIONAL_CAPABILITY_OFFSET (13) +#define EMBER_AF_GP_NOTIFICATION_OPTION_PROXY_INFO_PRESENT (0x4000) +#define EMBER_AF_GP_NOTIFICATION_OPTION_PROXY_INFO_PRESENT_OFFSET (14) +#define EMBER_AF_GP_NOTIFICATION_OPTION_RESERVED (0x8000) +#define EMBER_AF_GP_NOTIFICATION_OPTION_RESERVED_OFFSET (15) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_UNICAST_SINKS (0x0008) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_UNICAST_SINKS_OFFSET (3) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_DERIVED_GROUPCAST_SINKS (0x0010) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_DERIVED_GROUPCAST_SINKS_OFFSET (4) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_COMMISSIONED_GROUPCAST_SINKS (0x0020) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_COMMISSIONED_GROUPCAST_SINKS_OFFSET (5) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_GPD_SECURITY_FRAME_COUNTER (0x0040) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_GPD_SECURITY_FRAME_COUNTER_OFFSET (6) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_GPD_SECURITY_KEY (0x0080) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_REQUEST_GPD_SECURITY_KEY_OFFSET (7) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_RESERVED (0xFF00) +#define EMBER_AF_GP_PAIRING_SEARCH_OPTION_RESERVED_OFFSET (8) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_APPLICATION_ID (0x07) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_ALSO_DERIVED_GROUP (0x08) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_ALSO_DERIVED_GROUP_OFFSET (3) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_ALSO_COMMISSIONED_GROUP (0x10) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_ALSO_COMMISSIONED_GROUP_OFFSET (4) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_RESERVED (0xE0) +#define EMBER_AF_GP_TUNNELING_STOP_OPTION_RESERVED_OFFSET (5) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_RX_AFTER_TX (0x0008) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_RX_AFTER_TX_OFFSET (3) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_LEVEL (0x0030) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_LEVEL_OFFSET (4) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_KEY_TYPE (0x01C0) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_KEY_TYPE_OFFSET (6) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_PROCESSING_FAILED (0x0200) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_SECURITY_PROCESSING_FAILED_OFFSET (9) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_BIDIRECTIONAL_CAPABILITY (0x0400) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_BIDIRECTIONAL_CAPABILITY_OFFSET (10) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_PROXY_INFO_PRESENT (0x0800) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_PROXY_INFO_PRESENT_OFFSET (11) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_RESERVED (0xF000) +#define EMBER_AF_GP_COMMISSIONING_NOTIFICATION_OPTION_RESERVED_OFFSET (12) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_ACTION (0x01) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_GPM_IN_SECURITY (0x02) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_GPM_IN_SECURITY_OFFSET (1) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_GPM_IN_PAIRING (0x04) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_GPM_IN_PAIRING_OFFSET (2) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_PROXIES (0x08) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_INVOLVE_PROXIES_OFFSET (3) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_RESERVED (0xF0) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_OPTIONS_RESERVED_OFFSET (4) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_ON_COMMISSIONING_WINDOW_EXPIRATION (0x01) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_ON_FIRST_PAIRING_SUCCESS (0x02) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_ON_FIRST_PAIRING_SUCCESS_OFFSET (1) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_ON_GP_PROXY_COMMISSIONING_MODE_EXIT (0x04) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_ON_GP_PROXY_COMMISSIONING_MODE_EXIT_OFFSET (2) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_RESERVED (0xF8) +#define EMBER_AF_GP_SINK_COMMISSIONING_MODE_EXIT_MODE_RESERVED_OFFSET (3) +#define EMBER_AF_GP_SINK_TABLE_REQUEST_OPTIONS_APPLICATION_ID (0x07) +#define EMBER_AF_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TYPE (0x18) +#define EMBER_AF_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_OFFSET (3) +#define EMBER_AF_GP_SINK_TABLE_REQUEST_OPTIONS_RESERVED (0xE0) +#define EMBER_AF_GP_SINK_TABLE_REQUEST_OPTIONS_RESERVED_OFFSET (5) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_ACTION (0x0018) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_ACTION_OFFSET (3) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_NUMBER_OF_TRANSLATIONS (0x00E0) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_NUMBER_OF_TRANSLATIONS_OFFSET (5) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_ADDITIONAL_INFORMATION_BLOCK_PRESENT (0x0100) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_ADDITIONAL_INFORMATION_BLOCK_PRESENT_OFFSET (8) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_RESERVED (0xFE00) +#define EMBER_AF_GP_TRANSLATION_TABLE_UPDATE_OPTION_RESERVED_OFFSET (9) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_GPD_ID (0x01) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_CMD_ID (0x02) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_CMD_ID_OFFSET (1) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_PAYLOAD (0x04) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_PAYLOAD_OFFSET (2) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_ZB_ENDPOINT (0x08) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_ZB_ENDPOINT_OFFSET (3) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_ADDITIONAL_INFO_BLOCK (0x10) +#define EMBER_AF_GP_TRANSLATION_TABLE_SCAN_LEVEL_ADDITIONAL_INFO_BLOCK_OFFSET (4) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_ACTIONS_ACTION (0x07) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_ACTIONS_SEND_GP_PAIRING (0x08) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_ACTIONS_SEND_GP_PAIRING_OFFSET (3) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_ACTIONS_RESERVED (0xF0) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_ACTIONS_RESERVED_OFFSET (4) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE (0x0018) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_OFFSET (3) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_SEQUENCE_NUMBER_CAPABILITIES (0x0020) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_SEQUENCE_NUMBER_CAPABILITIES_OFFSET (5) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_RX_ON_CAPABILITY (0x0040) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_RX_ON_CAPABILITY_OFFSET (6) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_FIXED_LOCATION (0x0080) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_FIXED_LOCATION_OFFSET (7) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_ASSIGNED_ALIAS (0x0100) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_ASSIGNED_ALIAS_OFFSET (8) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_SECURITY_USE (0x0200) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_SECURITY_USE_OFFSET (9) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_APPLICATION_INFORMATION_PRESENT (0x0400) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_APPLICATION_INFORMATION_PRESENT_OFFSET (10) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_RESERVED (0xF800) +#define EMBER_AF_GP_PAIRING_CONFIGURATION_OPTION_RESERVED_OFFSET (11) +#define EMBER_AF_GP_APPLICATION_INFORMATION_MANUFACTURE_ID_PRESENT (0x01) +#define EMBER_AF_GP_APPLICATION_INFORMATION_MODEL_ID_PRESENT (0x02) +#define EMBER_AF_GP_APPLICATION_INFORMATION_MODEL_ID_PRESENT_OFFSET (1) +#define EMBER_AF_GP_APPLICATION_INFORMATION_GPD_COMMANDS_PRESENT (0x04) +#define EMBER_AF_GP_APPLICATION_INFORMATION_GPD_COMMANDS_PRESENT_OFFSET (2) +#define EMBER_AF_GP_APPLICATION_INFORMATION_CLUSTER_LIST_PRESENT (0x08) +#define EMBER_AF_GP_APPLICATION_INFORMATION_CLUSTER_LIST_PRESENT_OFFSET (3) +#define EMBER_AF_GP_APPLICATION_INFORMATION_SWITCH_INFORMATION_PRESENT (0x10) +#define EMBER_AF_GP_APPLICATION_INFORMATION_SWITCH_INFORMATION_PRESENT_OFFSET (4) +#define EMBER_AF_GP_APPLICATION_INFORMATION_APPLICATION_DESCRIPTION_PRESENT (0x20) +#define EMBER_AF_GP_APPLICATION_INFORMATION_APPLICATION_DESCRIPTION_PRESENT_OFFSET (5) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_APPLICATION_ID (0x07) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_FIRST_TO_FORWARD (0x08) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_FIRST_TO_FORWARD_OFFSET (3) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_NO_PAIRING (0x10) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_NO_PAIRING_OFFSET (4) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_RESERVED (0xE0) +#define EMBER_AF_GP_NOTIFICATION_RESPONSE_OPTION_RESERVED_OFFSET (5) +#define EMBER_AF_GP_PAIRING_OPTION_APPLICATION_ID (0x000007) +#define EMBER_AF_GP_PAIRING_OPTION_ADD_SINK (0x000008) +#define EMBER_AF_GP_PAIRING_OPTION_ADD_SINK_OFFSET (3) +#define EMBER_AF_GP_PAIRING_OPTION_REMOVE_GPD (0x000010) +#define EMBER_AF_GP_PAIRING_OPTION_REMOVE_GPD_OFFSET (4) +#define EMBER_AF_GP_PAIRING_OPTION_COMMUNICATION_MODE (0x000060) +#define EMBER_AF_GP_PAIRING_OPTION_COMMUNICATION_MODE_OFFSET (5) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_FIXED (0x000080) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_FIXED_OFFSET (7) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_MAC_SEQUENCE_NUMBER_CAPABILITIES (0x000100) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_MAC_SEQUENCE_NUMBER_CAPABILITIES_OFFSET (8) +#define EMBER_AF_GP_PAIRING_OPTION_SECURITY_LEVEL (0x000600) +#define EMBER_AF_GP_PAIRING_OPTION_SECURITY_LEVEL_OFFSET (9) +#define EMBER_AF_GP_PAIRING_OPTION_SECURITY_KEY_TYPE (0x003800) +#define EMBER_AF_GP_PAIRING_OPTION_SECURITY_KEY_TYPE_OFFSET (11) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_SECURITY_FRAME_COUNTER_PRESENT (0x004000) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_SECURITY_FRAME_COUNTER_PRESENT_OFFSET (14) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_SECURITY_KEY_PRESENT (0x008000) +#define EMBER_AF_GP_PAIRING_OPTION_GPD_SECURITY_KEY_PRESENT_OFFSET (15) +#define EMBER_AF_GP_PAIRING_OPTION_ASSIGNED_ALIAS_PRESENT (0x010000) +#define EMBER_AF_GP_PAIRING_OPTION_ASSIGNED_ALIAS_PRESENT_OFFSET (16) +#define EMBER_AF_GP_PAIRING_OPTION_GROUPCAST_RADIUS_PRESENT (0x020000) +#define EMBER_AF_GP_PAIRING_OPTION_GROUPCAST_RADIUS_PRESENT_OFFSET (17) +#define EMBER_AF_GP_PAIRING_OPTION_RESERVED (0xFC0000) +#define EMBER_AF_GP_PAIRING_OPTION_RESERVED_OFFSET (18) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_ACTION (0x01) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_COMMISSIONING_WINDOW_PRESENT (0x02) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_COMMISSIONING_WINDOW_PRESENT_OFFSET (1) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_EXIT_MODE (0x0C) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_EXIT_MODE_OFFSET (2) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_CHANNEL_PRESENT (0x10) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_CHANNEL_PRESENT_OFFSET (4) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_UNICAST_COMMUNICATION (0x20) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_UNICAST_COMMUNICATION_OFFSET (5) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_RESERVED (0xC0) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_OPTION_RESERVED_OFFSET (6) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_COMMISSIONING_WINDOW_EXPIRATION (0x02) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_COMMISSIONING_WINDOW_EXPIRATION_OFFSET (1) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_FIRST_PAIRING_SUCCESS (0x04) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_FIRST_PAIRING_SUCCESS_OFFSET (2) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_GP_PROXY_COMMISSIONING_MODE_EXIT (0x08) +#define EMBER_AF_GP_PROXY_COMMISSIONING_MODE_EXIT_MODE_ON_GP_PROXY_COMMISSIONING_MODE_EXIT_OFFSET (3) +#define EMBER_AF_GP_RESPONSE_OPTION_APPLICATION_ID (0x07) +#define EMBER_AF_GP_RESPONSE_OPTION_TRANSMIT_ON_END_POINT_MATCH (0x08) +#define EMBER_AF_GP_RESPONSE_OPTION_TRANSMIT_ON_END_POINT_MATCH_OFFSET (3) +#define EMBER_AF_GP_RESPONSE_OPTION_RESERVED (0xF0) +#define EMBER_AF_GP_RESPONSE_OPTION_RESERVED_OFFSET (4) +#define EMBER_AF_GP_RESPONSE_TEMP_MASTER_TX_CHANNEL_TRANSMIT_CHANNEL (0x0F) +#define EMBER_AF_GP_RESPONSE_TEMP_MASTER_TX_CHANNEL_RESERVED (0xF0) +#define EMBER_AF_GP_RESPONSE_TEMP_MASTER_TX_CHANNEL_RESERVED_OFFSET (4) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_APPLICATION_ID (0x0007) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_COMMUNICATION_MODE (0x0018) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_COMMUNICATION_MODE_OFFSET (3) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_SEQUENCE_NUM_CAPABILITIES (0x0020) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_SEQUENCE_NUM_CAPABILITIES_OFFSET (5) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_RX_ON_CAPABILITY (0x0040) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_RX_ON_CAPABILITY_OFFSET (6) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_FIXED_LOCATION (0x0080) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_FIXED_LOCATION_OFFSET (7) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_ASSIGNED_ALIAS (0x0100) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_ASSIGNED_ALIAS_OFFSET (8) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_SECURITY_USE (0x0200) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_SECURITY_USE_OFFSET (9) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_RESERVED (0xFC00) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_OPTIONS_RESERVED_OFFSET (10) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_LEVEL (0x03) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_KEY_TYPE (0x1C) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_SECURITY_OPTIONS_SECURITY_KEY_TYPE_OFFSET (2) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_SECURITY_OPTIONS_RESERVED (0xE0) +#define EMBER_AF_GP_SINK_TABLE_ENTRY_SECURITY_OPTIONS_RESERVED_OFFSET (5) +#define EMBER_AF_GP_TRANSLATION_TABLE_RESPONSE_OPTION_APPLICATION_ID (0x07) +#define EMBER_AF_GP_TRANSLATION_TABLE_RESPONSE_OPTION_ADDITIONAL_INFORMATION_BLOCK_PRESENT (0x08) +#define EMBER_AF_GP_TRANSLATION_TABLE_RESPONSE_OPTION_ADDITIONAL_INFORMATION_BLOCK_PRESENT_OFFSET (3) +#define EMBER_AF_GP_TRANSLATION_TABLE_RESPONSE_OPTION_RESERVED (0xF0) +#define EMBER_AF_GP_TRANSLATION_TABLE_RESPONSE_OPTION_RESERVED_OFFSET (4) +#define EMBER_AF_GP_PROXY_TABLE_REQUEST_OPTIONS_APPLICATION_ID (0x07) +#define EMBER_AF_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE (0x18) +#define EMBER_AF_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_OFFSET (3) +#define EMBER_AF_GP_PROXY_TABLE_REQUEST_OPTIONS_RESERVED (0xE0) +#define EMBER_AF_GP_PROXY_TABLE_REQUEST_OPTIONS_RESERVED_OFFSET (5) +#define EMBER_AF_GP_GPD_CHANNEL_REQUEST_CHANNEL_TOGGLING_BEHAVIOUR_RX_CHANNEL_NEXT_ATTEMPT (0x0F) +#define EMBER_AF_GP_GPD_CHANNEL_REQUEST_CHANNEL_TOGGLING_BEHAVIOUR_RX_CHANNEL_SECOND_NEXT_ATTEMPT (0xF0) +#define EMBER_AF_GP_GPD_CHANNEL_REQUEST_CHANNEL_TOGGLING_BEHAVIOUR_RX_CHANNEL_SECOND_NEXT_ATTEMPT_OFFSET (4) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_MASK (0x1F) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_OPERATIONAL_CHANNEL (0x0F) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_BASIC (0x10) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_BASIC_OFFSET (4) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_RESERVED (0xE0) +#define EMBER_AF_GP_GPD_CHANNEL_CONFIGURATION_CHANNEL_RESERVED_OFFSET (5) +#define EMBER_AF_GP_RESPONSE_OPTION_MASK (0x0F) +#define EMBER_AF_GP_RESPONSE_OPTION_TRANSMIT_ON_END_POINT_MATCH (0x08) +#define EMBER_AF_GP_RESPONSE_OPTION_TRANSMIT_ON_END_POINT_MATCH_OFFSET (3) +#define EMBER_AF_GP_RESPONSE_OPTION_RESERVED (0xF0) +#define EMBER_AF_GP_RESPONSE_OPTION_RESERVED_OFFSET (4) +/** @} END Enums */ +/** @} END addtogroup */ +#endif // SILABS_EMBER_AF_ENUMS diff --git a/examples/wifi-echo/server/esp32/main/gen/gen_config.h b/examples/wifi-echo/server/esp32/main/gen/gen_config.h new file mode 100644 index 00000000000000..e544d309f7c519 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/gen_config.h @@ -0,0 +1,269 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_ZNET_CONFIG +#define SILABS_ZNET_CONFIG + + +/**** Included Header Section ****/ + + + +// Networks +#define EM_AF_GENERATED_NETWORK_TYPES { \ + EM_AF_NETWORK_TYPE_ZIGBEE_PRO, /* Primary */ \ +} +#define EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS { \ + { \ + /* Primary */ \ + ZA_ROUTER, \ + EMBER_AF_SECURITY_PROFILE_Z3, \ + }, \ +} +#define EM_AF_GENERATED_NETWORK_STRINGS \ + "Primary (pro)", \ +/**** ZCL Section ****/ +#define ZA_PROMPT "ZigbeeMinimalSoc" +#define ZCL_USING_ON_OFF_CLUSTER_SERVER +#define EMBER_AF_MANUFACTURER_CODE 0x1002 +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_ALWAYS + +/**** Cluster endpoint counts ****/ +#define EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT (1) + +/**** Cluster Endpoint Summaries ****/ +#define EMBER_AF_MAX_SERVER_CLUSTER_COUNT (1) +#define EMBER_AF_MAX_CLIENT_CLUSTER_COUNT (0) +#define EMBER_AF_MAX_TOTAL_CLUSTER_COUNT (1) + +/**** CLI Section ****/ +#define EMBER_AF_GENERATE_CLI + +/**** Security Section ****/ +#define EMBER_AF_HAS_SECURITY_PROFILE_Z3 + +/**** Network Section ****/ +#define EMBER_SUPPORTED_NETWORKS (1) +#define EMBER_AF_NETWORK_INDEX_PRIMARY (0) +#define EMBER_AF_DEFAULT_NETWORK_INDEX EMBER_AF_NETWORK_INDEX_PRIMARY +#define EMBER_AF_HAS_ROUTER_NETWORK +#define EMBER_AF_HAS_RX_ON_WHEN_IDLE_NETWORK +#define EMBER_AF_TX_POWER_MODE EMBER_TX_POWER_MODE_USE_TOKEN + +/**** Callback Section ****/ +#define EMBER_CALLBACK_STACK_STATUS +#define EMBER_CALLBACK_ON_OFF_CLUSTER_OFF +#define EMBER_CALLBACK_ON_OFF_CLUSTER_ON +#define EMBER_CALLBACK_ON_OFF_CLUSTER_TOGGLE +#define EMBER_CALLBACK_ENERGY_SCAN_RESULT +#define EMBER_CALLBACK_SCAN_COMPLETE +#define EMBER_CALLBACK_NETWORK_FOUND +/**** Debug printing section ****/ + +// Global switch +#define EMBER_AF_PRINT_ENABLE +// Individual areas +#define EMBER_AF_PRINT_CORE 0x0001 +#define EMBER_AF_PRINT_DEBUG 0x0002 +#define EMBER_AF_PRINT_APP 0x0004 +#define EMBER_AF_PRINT_ZDO 0x0008 +#define EMBER_AF_PRINT_BITS { 0x0F } +#define EMBER_AF_PRINT_NAMES { \ + "Core",\ + "Debug",\ + "Application",\ + "ZDO (ZigBee Device Object)",\ + NULL\ +} +#define EMBER_AF_PRINT_NAME_NUMBER 4 + + +#define EMBER_AF_SUPPORT_COMMAND_DISCOVERY + + +// Generated plugin macros + +// Use this macro to check if Antenna Stub plugin is included +#define EMBER_AF_PLUGIN_ANTENNA_STUB + +// Use this macro to check if Binding Table Library plugin is included +#define EMBER_AF_PLUGIN_BINDING_TABLE_LIBRARY +// User options for plugin Binding Table Library +#define EMBER_BINDING_TABLE_SIZE 10 + +// Use this macro to check if CCM* Encryption plugin is included +#define EMBER_AF_PLUGIN_CCM_ENCRYPTION +// User options for plugin CCM* Encryption +#define EMBER_AF_PLUGIN_CCM_ENCRYPTION_SOFTWARE_CCM +#define USE_SOFTWARE_CCM + +// Use this macro to check if Radio Coexistence Stub plugin is included +#define EMBER_AF_PLUGIN_COEXISTENCE_STUB + +// Use this macro to check if Debug Basic Library plugin is included +#define EMBER_AF_PLUGIN_DEBUG_BASIC_LIBRARY + +// Use this macro to check if Debug JTAG plugin is included +#define EMBER_AF_PLUGIN_DEBUG_JTAG + +// Use this macro to check if Ember Minimal Printf plugin is included +#define EMBER_AF_PLUGIN_EMBER_MINIMAL_PRINTF + +// Use this macro to check if HAL Library plugin is included +#define EMBER_AF_PLUGIN_HAL_LIBRARY + +// Use this macro to check if mbed TLS plugin is included +#define EMBER_AF_PLUGIN_MBEDTLS +// User options for plugin mbed TLS +#define EMBER_AF_PLUGIN_MBEDTLS_CONF_DEVICE_ACCELERATION +#define EMBER_AF_PLUGIN_MBEDTLS_CONF_DEVICE_ACCELERATION_APP + +// Use this macro to check if Network Steering plugin is included +#define EMBER_AF_PLUGIN_NETWORK_STEERING +// User options for plugin Network Steering +#define EMBER_AF_PLUGIN_NETWORK_STEERING_CHANNEL_MASK 0x0318C800 +#define EMBER_AF_PLUGIN_NETWORK_STEERING_RADIO_TX_POWER 3 +#define EMBER_AF_PLUGIN_NETWORK_STEERING_SCAN_DURATION 4 +#define EMBER_AF_PLUGIN_NETWORK_STEERING_COMMISSIONING_TIME_S 180 +#define EMBER_AF_PLUGIN_NETWORK_STEERING_OPTIMIZE_SCANS + +// Use this macro to check if NVM3 Library plugin is included +#define EMBER_AF_PLUGIN_NVM3 +// User options for plugin NVM3 Library +#define EMBER_AF_PLUGIN_NVM3_FLASH_PAGES 18 +#define EMBER_AF_PLUGIN_NVM3_CACHE_SIZE 200 +#define EMBER_AF_PLUGIN_NVM3_MAX_OBJECT_SIZE 254 +#define EMBER_AF_PLUGIN_NVM3_USER_REPACK_HEADROOM 0 + +// Use this macro to check if Packet Validate Library plugin is included +#define EMBER_AF_PLUGIN_PACKET_VALIDATE_LIBRARY + +// Use this macro to check if RAIL Library plugin is included +#define EMBER_AF_PLUGIN_RAIL_LIBRARY +// User options for plugin RAIL Library +#define EMBER_AF_PLUGIN_RAIL_LIBRARY_RAILPHYDEF 1 + +// Use this macro to check if Scan Dispatch plugin is included +#define EMBER_AF_PLUGIN_SCAN_DISPATCH +// User options for plugin Scan Dispatch +#define EMBER_AF_PLUGIN_SCAN_DISPATCH_SCAN_QUEUE_SIZE 10 + +// Use this macro to check if Serial plugin is included +#define EMBER_AF_PLUGIN_SERIAL + +// Use this macro to check if Simulated EEPROM version 2 to NVM3 Upgrade Stub plugin is included +#define EMBER_AF_PLUGIN_SIM_EEPROM2_TO_NVM3_UPGRADE_STUB + +// Use this macro to check if Simple Main plugin is included +#define EMBER_AF_PLUGIN_SIMPLE_MAIN + +// Use this macro to check if Strong Random plugin is included +#define EMBER_AF_PLUGIN_STRONG_RANDOM +// User options for plugin Strong Random +#define EMBER_AF_PLUGIN_STRONG_RANDOM_RADIO_PRNG +#define USE_RADIO_API_FOR_TRNG + +// Use this macro to check if Update TC Link Key plugin is included +#define EMBER_AF_PLUGIN_UPDATE_TC_LINK_KEY +// User options for plugin Update TC Link Key +#define EMBER_AF_PLUGIN_UPDATE_TC_LINK_KEY_MAX_ATTEMPTS 3 + +// Use this macro to check if ZCL Framework Core plugin is included +#define EMBER_AF_PLUGIN_ZCL_FRAMEWORK_CORE +// User options for plugin ZCL Framework Core +#define EMBER_AF_PLUGIN_ZCL_FRAMEWORK_CORE_CLI_ENABLED +#define ZA_CLI_FULL + +// Use this macro to check if ZigBee PRO Stack Library plugin is included +#define EMBER_AF_PLUGIN_ZIGBEE_PRO_LIBRARY +// User options for plugin ZigBee PRO Stack Library +#define EMBER_MAX_END_DEVICE_CHILDREN 6 +#define EMBER_PACKET_BUFFER_COUNT 75 +#define EMBER_END_DEVICE_KEEP_ALIVE_SUPPORT_MODE EMBER_KEEP_ALIVE_SUPPORT_ALL +#define EMBER_END_DEVICE_POLL_TIMEOUT MINUTES_256 +#define EMBER_END_DEVICE_POLL_TIMEOUT_SHIFT 6 +#define EMBER_LINK_POWER_DELTA_INTERVAL 300 +#define EMBER_APS_UNICAST_MESSAGE_COUNT 10 +#define EMBER_BROADCAST_TABLE_SIZE 15 +#define EMBER_NEIGHBOR_TABLE_SIZE 16 + + +// Generated API headers + +// API antenna from Antenna Stub plugin +#define EMBER_AF_API_ANTENNA "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/antenna/antenna.h" + +// API coexistence from Radio Coexistence Stub plugin +#define EMBER_AF_API_COEXISTENCE "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/plugin/coexistence/protocol/ieee802154/coexistence-802154.h" + +// API network-steering from Network Steering plugin +#define EMBER_AF_API_NETWORK_STEERING "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/network-steering/network-steering.h" + +// API nvm3 from NVM3 Library plugin +#define EMBER_AF_API_NVM3 "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/nvm3/nvm3-token.h" + +// API rail-library from RAIL Library plugin +#define EMBER_AF_API_RAIL_LIBRARY "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/common/rail.h" + +// API scan-dispatch from Scan Dispatch plugin +#define EMBER_AF_API_SCAN_DISPATCH "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/scan-dispatch/scan-dispatch.h" + +// API serial from Serial plugin +#define EMBER_AF_API_SERIAL "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/serial/serial.h" + +// API update-tc-link-key from Update TC Link Key plugin +#define EMBER_AF_API_UPDATE_TC_LINK_KEY "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/update-tc-link-key/update-tc-link-key.h" + +// API command-interpreter2 from ZCL Framework Core plugin +#define EMBER_AF_API_COMMAND_INTERPRETER2 "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/util/serial/command-interpreter2.h" + + +// Custom macros +#ifdef TRANSITION_TIME_DS +#undef TRANSITION_TIME_DS +#endif +#define TRANSITION_TIME_DS 20 + +#ifdef FINDING_AND_BINDING_DELAY_MS +#undef FINDING_AND_BINDING_DELAY_MS +#endif +#define FINDING_AND_BINDING_DELAY_MS 3000 + + + +#endif // SILABS_ZNET_CONFIG diff --git a/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h b/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h new file mode 100644 index 00000000000000..bda4e8c1ad9a9b --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h @@ -0,0 +1,63 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// This file contains the tokens for attributes stored in flash + + +// Identifier tags for tokens + + +// Types for the tokens +#ifdef DEFINETYPES +#endif // DEFINETYPES + + +// Actual token definitions +#ifdef DEFINETOKENS +#endif // DEFINETOKENS + + +// Macro snippet that loads all the attributes from tokens +#define GENERATED_TOKEN_LOADER(endpoint) do {\ +} while(false) + + +// Macro snippet that saves the attribute to token +#define GENERATED_TOKEN_SAVER do {\ +} while(false) + + diff --git a/examples/wifi-echo/server/esp32/main/gen/print-cluster.h b/examples/wifi-echo/server/esp32/main/gen/print-cluster.h new file mode 100644 index 00000000000000..fc3468704b7f20 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/print-cluster.h @@ -0,0 +1,707 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_PRINT_CLUSTER +#define SILABS_PRINT_CLUSTER + + +// This is the mapping of IDs to cluster names assuming a format according +// to the "EmberAfClusterName" defined in the ZCL header. +// The names of clusters that are not present, are removed. + + + +#if defined(ZCL_USING_BASIC_CLUSTER_SERVER) || defined(ZCL_USING_BASIC_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BASIC_CLUSTER {ZCL_BASIC_CLUSTER_ID, 0x0000, "Basic" }, +#else + #define SILABS_PRINTCLUSTER_BASIC_CLUSTER +#endif +#if defined(ZCL_USING_POWER_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_POWER_CONFIG_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER {ZCL_POWER_CONFIG_CLUSTER_ID, 0x0000, "Power Configuration" }, +#else + #define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER +#endif +#if defined(ZCL_USING_DEVICE_TEMP_CLUSTER_SERVER) || defined(ZCL_USING_DEVICE_TEMP_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER {ZCL_DEVICE_TEMP_CLUSTER_ID, 0x0000, "Device Temperature Configuration" }, +#else + #define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER +#endif +#if defined(ZCL_USING_IDENTIFY_CLUSTER_SERVER) || defined(ZCL_USING_IDENTIFY_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER {ZCL_IDENTIFY_CLUSTER_ID, 0x0000, "Identify" }, +#else + #define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER +#endif +#if defined(ZCL_USING_GROUPS_CLUSTER_SERVER) || defined(ZCL_USING_GROUPS_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_GROUPS_CLUSTER {ZCL_GROUPS_CLUSTER_ID, 0x0000, "Groups" }, +#else + #define SILABS_PRINTCLUSTER_GROUPS_CLUSTER +#endif +#if defined(ZCL_USING_SCENES_CLUSTER_SERVER) || defined(ZCL_USING_SCENES_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SCENES_CLUSTER {ZCL_SCENES_CLUSTER_ID, 0x0000, "Scenes" }, +#else + #define SILABS_PRINTCLUSTER_SCENES_CLUSTER +#endif +#if defined(ZCL_USING_ON_OFF_CLUSTER_SERVER) || defined(ZCL_USING_ON_OFF_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER {ZCL_ON_OFF_CLUSTER_ID, 0x0000, "On/off" }, +#else + #define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER +#endif +#if defined(ZCL_USING_ON_OFF_SWITCH_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_ON_OFF_SWITCH_CONFIG_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER {ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID, 0x0000, "On/off Switch Configuration" }, +#else + #define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER +#endif +#if defined(ZCL_USING_LEVEL_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_LEVEL_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER {ZCL_LEVEL_CONTROL_CLUSTER_ID, 0x0000, "Level Control" }, +#else + #define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_ALARM_CLUSTER_SERVER) || defined(ZCL_USING_ALARM_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ALARM_CLUSTER {ZCL_ALARM_CLUSTER_ID, 0x0000, "Alarms" }, +#else + #define SILABS_PRINTCLUSTER_ALARM_CLUSTER +#endif +#if defined(ZCL_USING_TIME_CLUSTER_SERVER) || defined(ZCL_USING_TIME_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TIME_CLUSTER {ZCL_TIME_CLUSTER_ID, 0x0000, "Time" }, +#else + #define SILABS_PRINTCLUSTER_TIME_CLUSTER +#endif +#if defined(ZCL_USING_RSSI_LOCATION_CLUSTER_SERVER) || defined(ZCL_USING_RSSI_LOCATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER {ZCL_RSSI_LOCATION_CLUSTER_ID, 0x0000, "RSSI Location" }, +#else + #define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER +#endif +#if defined(ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_SERVER) || defined(ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER {ZCL_BINARY_INPUT_BASIC_CLUSTER_ID, 0x0000, "Binary Input (Basic)" }, +#else + #define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER +#endif +#if defined(ZCL_USING_COMMISSIONING_CLUSTER_SERVER) || defined(ZCL_USING_COMMISSIONING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER {ZCL_COMMISSIONING_CLUSTER_ID, 0x0000, "Commissioning" }, +#else + #define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER +#endif +#if defined(ZCL_USING_PARTITION_CLUSTER_SERVER) || defined(ZCL_USING_PARTITION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PARTITION_CLUSTER {ZCL_PARTITION_CLUSTER_ID, 0x0000, "Partition" }, +#else + #define SILABS_PRINTCLUSTER_PARTITION_CLUSTER +#endif +#if defined(ZCL_USING_OTA_BOOTLOAD_CLUSTER_SERVER) || defined(ZCL_USING_OTA_BOOTLOAD_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER {ZCL_OTA_BOOTLOAD_CLUSTER_ID, 0x0000, "Over the Air Bootloading" }, +#else + #define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER +#endif +#if defined(ZCL_USING_POWER_PROFILE_CLUSTER_SERVER) || defined(ZCL_USING_POWER_PROFILE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER {ZCL_POWER_PROFILE_CLUSTER_ID, 0x0000, "Power Profile" }, +#else + #define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER +#endif +#if defined(ZCL_USING_APPLIANCE_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER {ZCL_APPLIANCE_CONTROL_CLUSTER_ID, 0x0000, "Appliance Control" }, +#else + #define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_POLL_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_POLL_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER {ZCL_POLL_CONTROL_CLUSTER_ID, 0x0000, "Poll Control" }, +#else + #define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_GREEN_POWER_CLUSTER_SERVER) || defined(ZCL_USING_GREEN_POWER_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER {ZCL_GREEN_POWER_CLUSTER_ID, 0x0000, "Green Power" }, +#else + #define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER +#endif +#if defined(ZCL_USING_KEEPALIVE_CLUSTER_SERVER) || defined(ZCL_USING_KEEPALIVE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER {ZCL_KEEPALIVE_CLUSTER_ID, 0x0000, "Keep-Alive" }, +#else + #define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER +#endif +#if defined(ZCL_USING_SHADE_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_SHADE_CONFIG_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER {ZCL_SHADE_CONFIG_CLUSTER_ID, 0x0000, "Shade Configuration" }, +#else + #define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER +#endif +#if defined(ZCL_USING_DOOR_LOCK_CLUSTER_SERVER) || defined(ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER {ZCL_DOOR_LOCK_CLUSTER_ID, 0x0000, "Door Lock" }, +#else + #define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER +#endif +#if defined(ZCL_USING_WINDOW_COVERING_CLUSTER_SERVER) || defined(ZCL_USING_WINDOW_COVERING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER {ZCL_WINDOW_COVERING_CLUSTER_ID, 0x0000, "Window Covering" }, +#else + #define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER +#endif +#if defined(ZCL_USING_BARRIER_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_BARRIER_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER {ZCL_BARRIER_CONTROL_CLUSTER_ID, 0x0000, "Barrier Control" }, +#else + #define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_PUMP_CONFIG_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_PUMP_CONFIG_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER {ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID, 0x0000, "Pump Configuration and Control" }, +#else + #define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_THERMOSTAT_CLUSTER_SERVER) || defined(ZCL_USING_THERMOSTAT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER {ZCL_THERMOSTAT_CLUSTER_ID, 0x0000, "Thermostat" }, +#else + #define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER +#endif +#if defined(ZCL_USING_FAN_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_FAN_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER {ZCL_FAN_CONTROL_CLUSTER_ID, 0x0000, "Fan Control" }, +#else + #define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_DEHUMID_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DEHUMID_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER {ZCL_DEHUMID_CONTROL_CLUSTER_ID, 0x0000, "Dehumidification Control" }, +#else + #define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_THERMOSTAT_UI_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_THERMOSTAT_UI_CONFIG_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER {ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID, 0x0000, "Thermostat User Interface Configuration" }, +#else + #define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER +#endif +#if defined(ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_COLOR_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER {ZCL_COLOR_CONTROL_CLUSTER_ID, 0x0000, "Color Control" }, +#else + #define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_SERVER) || defined(ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER {ZCL_BALLAST_CONFIGURATION_CLUSTER_ID, 0x0000, "Ballast Configuration" }, +#else + #define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER +#endif +#if defined(ZCL_USING_ILLUM_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ILLUM_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER {ZCL_ILLUM_MEASUREMENT_CLUSTER_ID, 0x0000, "Illuminance Measurement" }, +#else + #define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_ILLUM_LEVEL_SENSING_CLUSTER_SERVER) || defined(ZCL_USING_ILLUM_LEVEL_SENSING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER {ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID, 0x0000, "Illuminance Level Sensing" }, +#else + #define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER +#endif +#if defined(ZCL_USING_TEMP_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TEMP_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER {ZCL_TEMP_MEASUREMENT_CLUSTER_ID, 0x0000, "Temperature Measurement" }, +#else + #define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER {ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID, 0x0000, "Pressure Measurement" }, +#else + #define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_FLOW_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FLOW_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER {ZCL_FLOW_MEASUREMENT_CLUSTER_ID, 0x0000, "Flow Measurement" }, +#else + #define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER {ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID, 0x0000, "Relative Humidity Measurement" }, +#else + #define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_OCCUPANCY_SENSING_CLUSTER_SERVER) || defined(ZCL_USING_OCCUPANCY_SENSING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER {ZCL_OCCUPANCY_SENSING_CLUSTER_ID, 0x0000, "Occupancy Sensing" }, +#else + #define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER +#endif +#if defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Monoxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Dioxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Oxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Sulphide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitric Oxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitrogen Dioxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Oxygen Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ozone Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfur Dioxide Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Dissolved Oxygen Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromate Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloramines Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorine Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Fecal coliform and E. Coli Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Fluoride Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Haloacetic Acids Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Total Trihalomethanes Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Total Coliform Bacteria Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Turbidity Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Copper Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Lead Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Manganese Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfate Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromodichloromethane Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromoform Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorodibromomethane Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloroform Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sodium Concentration Measurement" }, +#else + #define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_IAS_ZONE_CLUSTER_SERVER) || defined(ZCL_USING_IAS_ZONE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER {ZCL_IAS_ZONE_CLUSTER_ID, 0x0000, "IAS Zone" }, +#else + #define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER +#endif +#if defined(ZCL_USING_IAS_ACE_CLUSTER_SERVER) || defined(ZCL_USING_IAS_ACE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER {ZCL_IAS_ACE_CLUSTER_ID, 0x0000, "IAS ACE" }, +#else + #define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER +#endif +#if defined(ZCL_USING_IAS_WD_CLUSTER_SERVER) || defined(ZCL_USING_IAS_WD_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER {ZCL_IAS_WD_CLUSTER_ID, 0x0000, "IAS WD" }, +#else + #define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER +#endif +#if defined(ZCL_USING_GENERIC_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_GENERIC_TUNNEL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER {ZCL_GENERIC_TUNNEL_CLUSTER_ID, 0x0000, "Generic Tunnel" }, +#else + #define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER +#endif +#if defined(ZCL_USING_BACNET_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_BACNET_PROTOCOL_TUNNEL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER {ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "BACnet Protocol Tunnel" }, +#else + #define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER +#endif +#if defined(ZCL_USING_11073_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_11073_PROTOCOL_TUNNEL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER {ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "11073 Protocol Tunnel" }, +#else + #define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER +#endif +#if defined(ZCL_USING_ISO7816_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_ISO7816_PROTOCOL_TUNNEL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER {ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "ISO 7816 Protocol Tunnel" }, +#else + #define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER +#endif +#if defined(ZCL_USING_PRICE_CLUSTER_SERVER) || defined(ZCL_USING_PRICE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PRICE_CLUSTER {ZCL_PRICE_CLUSTER_ID, 0x0000, "Price" }, +#else + #define SILABS_PRINTCLUSTER_PRICE_CLUSTER +#endif +#if defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER {ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, 0x0000, "Demand Response and Load Control" }, +#else + #define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_SIMPLE_METERING_CLUSTER_SERVER) || defined(ZCL_USING_SIMPLE_METERING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER {ZCL_SIMPLE_METERING_CLUSTER_ID, 0x0000, "Simple Metering" }, +#else + #define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER +#endif +#if defined(ZCL_USING_MESSAGING_CLUSTER_SERVER) || defined(ZCL_USING_MESSAGING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER {ZCL_MESSAGING_CLUSTER_ID, 0x0000, "Messaging" }, +#else + #define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER +#endif +#if defined(ZCL_USING_TUNNELING_CLUSTER_SERVER) || defined(ZCL_USING_TUNNELING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER {ZCL_TUNNELING_CLUSTER_ID, 0x0000, "Tunneling" }, +#else + #define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER +#endif +#if defined(ZCL_USING_PREPAYMENT_CLUSTER_SERVER) || defined(ZCL_USING_PREPAYMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER {ZCL_PREPAYMENT_CLUSTER_ID, 0x0000, "Prepayment" }, +#else + #define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER +#endif +#if defined(ZCL_USING_ENERGY_MANAGEMENT_CLUSTER_SERVER) || defined(ZCL_USING_ENERGY_MANAGEMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER {ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, 0x0000, "Energy Management" }, +#else + #define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER +#endif +#if defined(ZCL_USING_CALENDAR_CLUSTER_SERVER) || defined(ZCL_USING_CALENDAR_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER {ZCL_CALENDAR_CLUSTER_ID, 0x0000, "Calendar" }, +#else + #define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER +#endif +#if defined(ZCL_USING_DEVICE_MANAGEMENT_CLUSTER_SERVER) || defined(ZCL_USING_DEVICE_MANAGEMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER {ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, 0x0000, "Device Management" }, +#else + #define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER +#endif +#if defined(ZCL_USING_EVENTS_CLUSTER_SERVER) || defined(ZCL_USING_EVENTS_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_EVENTS_CLUSTER {ZCL_EVENTS_CLUSTER_ID, 0x0000, "Events" }, +#else + #define SILABS_PRINTCLUSTER_EVENTS_CLUSTER +#endif +#if defined(ZCL_USING_MDU_PAIRING_CLUSTER_SERVER) || defined(ZCL_USING_MDU_PAIRING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER {ZCL_MDU_PAIRING_CLUSTER_ID, 0x0000, "MDU Pairing" }, +#else + #define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER +#endif +#if defined(ZCL_USING_SUB_GHZ_CLUSTER_SERVER) || defined(ZCL_USING_SUB_GHZ_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER {ZCL_SUB_GHZ_CLUSTER_ID, 0x0000, "Sub-GHz" }, +#else + #define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER +#endif +#if defined(ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_SERVER) || defined(ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER {ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, 0x0000, "Key Establishment" }, +#else + #define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER +#endif +#if defined(ZCL_USING_INFORMATION_CLUSTER_SERVER) || defined(ZCL_USING_INFORMATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER {ZCL_INFORMATION_CLUSTER_ID, 0x0000, "Information" }, +#else + #define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER +#endif +#if defined(ZCL_USING_DATA_SHARING_CLUSTER_SERVER) || defined(ZCL_USING_DATA_SHARING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER {ZCL_DATA_SHARING_CLUSTER_ID, 0x0000, "Data Sharing" }, +#else + #define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER +#endif +#if defined(ZCL_USING_GAMING_CLUSTER_SERVER) || defined(ZCL_USING_GAMING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_GAMING_CLUSTER {ZCL_GAMING_CLUSTER_ID, 0x0000, "Gaming" }, +#else + #define SILABS_PRINTCLUSTER_GAMING_CLUSTER +#endif +#if defined(ZCL_USING_DATA_RATE_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DATA_RATE_CONTROL_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER {ZCL_DATA_RATE_CONTROL_CLUSTER_ID, 0x0000, "Data Rate Control" }, +#else + #define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER +#endif +#if defined(ZCL_USING_VOICE_OVER_ZIGBEE_CLUSTER_SERVER) || defined(ZCL_USING_VOICE_OVER_ZIGBEE_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER {ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, 0x0000, "Voice over ZigBee" }, +#else + #define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER +#endif +#if defined(ZCL_USING_CHATTING_CLUSTER_SERVER) || defined(ZCL_USING_CHATTING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_CHATTING_CLUSTER {ZCL_CHATTING_CLUSTER_ID, 0x0000, "Chatting" }, +#else + #define SILABS_PRINTCLUSTER_CHATTING_CLUSTER +#endif +#if defined(ZCL_USING_PAYMENT_CLUSTER_SERVER) || defined(ZCL_USING_PAYMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER {ZCL_PAYMENT_CLUSTER_ID, 0x0000, "Payment" }, +#else + #define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER +#endif +#if defined(ZCL_USING_BILLING_CLUSTER_SERVER) || defined(ZCL_USING_BILLING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_BILLING_CLUSTER {ZCL_BILLING_CLUSTER_ID, 0x0000, "Billing" }, +#else + #define SILABS_PRINTCLUSTER_BILLING_CLUSTER +#endif +#if defined(ZCL_USING_APPLIANCE_IDENTIFICATION_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_IDENTIFICATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER {ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID, 0x0000, "Appliance Identification" }, +#else + #define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER +#endif +#if defined(ZCL_USING_METER_IDENTIFICATION_CLUSTER_SERVER) || defined(ZCL_USING_METER_IDENTIFICATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER {ZCL_METER_IDENTIFICATION_CLUSTER_ID, 0x0000, "Meter Identification" }, +#else + #define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER +#endif +#if defined(ZCL_USING_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER {ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, 0x0000, "Appliance Events and Alert" }, +#else + #define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER +#endif +#if defined(ZCL_USING_APPLIANCE_STATISTICS_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_STATISTICS_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER {ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, 0x0000, "Appliance Statistics" }, +#else + #define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER +#endif +#if defined(ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER {ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, 0x0000, "Electrical Measurement" }, +#else + #define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER +#endif +#if defined(ZCL_USING_DIAGNOSTICS_CLUSTER_SERVER) || defined(ZCL_USING_DIAGNOSTICS_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER {ZCL_DIAGNOSTICS_CLUSTER_ID, 0x0000, "Diagnostics" }, +#else + #define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER +#endif +#if defined(ZCL_USING_ZLL_COMMISSIONING_CLUSTER_SERVER) || defined(ZCL_USING_ZLL_COMMISSIONING_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER {ZCL_ZLL_COMMISSIONING_CLUSTER_ID, 0x0000, "ZLL Commissioning" }, +#else + #define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER +#endif +#if defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_SERVER) || defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER {ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, 0x1002, "Sample Mfg Specific Cluster" }, +#else + #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER +#endif +#if defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_2_SERVER) || defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_2_CLIENT) + #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 {ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, 0x1049, "Sample Mfg Specific Cluster 2" }, +#else + #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 +#endif +#if defined(ZCL_USING_OTA_CONFIGURATION_CLUSTER_SERVER) || defined(ZCL_USING_OTA_CONFIGURATION_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER {ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, "Configuration Cluster" }, +#else + #define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER +#endif +#if defined(ZCL_USING_MFGLIB_CLUSTER_SERVER) || defined(ZCL_USING_MFGLIB_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER {ZCL_MFGLIB_CLUSTER_ID, 0x1002, "MFGLIB Cluster" }, +#else + #define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER +#endif +#if defined(ZCL_USING_SL_WWAH_CLUSTER_SERVER) || defined(ZCL_USING_SL_WWAH_CLUSTER_CLIENT) + #define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER {ZCL_SL_WWAH_CLUSTER_ID, 0x1217, "SL Works With All Hubs" }, +#else + #define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER +#endif +#define CLUSTER_IDS_TO_NAMES \ + SILABS_PRINTCLUSTER_BASIC_CLUSTER \ + SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER \ + SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER \ + SILABS_PRINTCLUSTER_GROUPS_CLUSTER \ + SILABS_PRINTCLUSTER_SCENES_CLUSTER \ + SILABS_PRINTCLUSTER_ON_OFF_CLUSTER \ + SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_ALARM_CLUSTER \ + SILABS_PRINTCLUSTER_TIME_CLUSTER \ + SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER \ + SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER \ + SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER \ + SILABS_PRINTCLUSTER_PARTITION_CLUSTER \ + SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER \ + SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER \ + SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER \ + SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ + SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ + SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER \ + SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER \ + SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER \ + SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER \ + SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_WD_CLUSTER \ + SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_PRICE_CLUSTER \ + SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER \ + SILABS_PRINTCLUSTER_MESSAGING_CLUSTER \ + SILABS_PRINTCLUSTER_TUNNELING_CLUSTER \ + SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CALENDAR_CLUSTER \ + SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER \ + SILABS_PRINTCLUSTER_EVENTS_CLUSTER \ + SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER \ + SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER \ + SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER \ + SILABS_PRINTCLUSTER_INFORMATION_CLUSTER \ + SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER \ + SILABS_PRINTCLUSTER_GAMING_CLUSTER \ + SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER \ + SILABS_PRINTCLUSTER_CHATTING_CLUSTER \ + SILABS_PRINTCLUSTER_PAYMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BILLING_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER \ + SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER \ + SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER \ + SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER \ + SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER \ + SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 \ + SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER \ + SILABS_PRINTCLUSTER_MFGLIB_CLUSTER \ + SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER \ + + +#define MAX_CLUSTER_NAME_LENGTH 52 +#endif // SILABS_PRINT_CLUSTER diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c new file mode 100644 index 00000000000000..0e788a1236f3fd --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c @@ -0,0 +1,121 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +#include PLATFORM_HEADER +#include CONFIGURATION_HEADER +#include "af.h" + +// Init function declarations. +void emberAfMainInitCallback(void); // Global +void emberAfInit(void); // Global + +void emAfInit(void) +{ + emberAfMainInitCallback(); // Global + emberAfInit(); // Global +} + +// Tick function declarations. +void emberAfMainTickCallback(void); // Global +void emberAfTick(void); // Global + +void emAfTick(void) +{ + emberAfMainTickCallback(); // Global + emberAfTick(); // Global +} + +// Marker function declarations. +void emberAfMarkBuffersCallback(void); // Global +void emberAfPluginNetworkSteeringMarker(void); // Plugin: network-steering + +void emAfMarkBuffers(void) +{ + emberAfMarkBuffersCallback(); // Global + emberAfPluginNetworkSteeringMarker(); // Plugin: network-steering +} + +void emAfResetAttributes(uint8_t endpointId) +{ +} + +// PreCommandReceived function declarations. +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); // Global + +bool emAfPreCommandReceived(EmberAfClusterCommand* cmd) +{ + return emberAfPreCommandReceivedCallback(cmd); // Global +} + +// PreZDOMessageReceived function declarations. +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length); // Global + +bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length) +{ + return emberAfPreZDOMessageReceivedCallback(emberNodeId, apsFrame, message, length); // Global +} + +bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength) +{ + return 0; // false +} + +// ZigbeeKeyEstablishment function declarations. +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Global +void emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Plugin: update-tc-link-key + +void emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status) +{ + emberAfZigbeeKeyEstablishmentCallback(partner, status); // Global + emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(partner, status); // Plugin: update-tc-link-key +} + +// ReadAttributesResponse function declarations. +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen); // Global + +bool emAfReadAttributesResponse(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen) +{ + return emberAfReadAttributesResponseCallback(clusterId, buffer, bufLen); // Global +} + +// ReportAttributes function declarations. +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen); // Global + +bool emAfReportAttributes(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen) +{ + return emberAfReportAttributesCallback(clusterId, buffer, bufLen); // Global +} diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h new file mode 100644 index 00000000000000..bad66db1eaab61 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h @@ -0,0 +1,67 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * + * Copyright (c) 2020 Silicon Labs + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_ZNET_BOOKKEEPING_H +#define SILABS_ZNET_BOOKKEEPING_H + + +#include PLATFORM_HEADER +#include CONFIGURATION_HEADER +#include "af.h" + +void emAfInit(void); + +void emAfTick(void); + +void emAfMarkBuffers(void); + +void emAfResetAttributes(uint8_t endpointId); + +bool emAfPreCommandReceived(EmberAfClusterCommand* cmd); + +bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length); + +bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength); + +void emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status); + +bool emAfReadAttributesResponse(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen); + +bool emAfReportAttributes(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen); + +#endif // SILABS_ZNET_BOOKKEEPING_H From 8745ea057fbb7f1fe711cbe4b1ad1269b43d884b Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Mon, 13 Jul 2020 15:31:15 -0400 Subject: [PATCH 03/12] Fix compile errors in types_stub.h This corrects various obvious problems in the file that prevent files that include it from compiling. --- .../wifi-echo/server/esp32/main/types_stub.h | 73 +++++++++---------- 1 file changed, 34 insertions(+), 39 deletions(-) diff --git a/examples/wifi-echo/server/esp32/main/types_stub.h b/examples/wifi-echo/server/esp32/main/types_stub.h index d2a2cffc8202c6..232789681fa8b8 100644 --- a/examples/wifi-echo/server/esp32/main/types_stub.h +++ b/examples/wifi-echo/server/esp32/main/types_stub.h @@ -39,6 +39,11 @@ * the CHIP project ******************************************************************************/ +#ifndef TYPES_STUB_H +#define TYPES_STUB_H + +#include // For mem* functions. + /** * @brief Defines binding types. */ @@ -255,6 +260,21 @@ typedef struct { uint8_t radius; } EmberApsFrame; +/** + * @brief Size of EUI64 (an IEEE address) in bytes (8). + */ +#define EUI64_SIZE 8 + +/** + * @brief Size of an encryption key in bytes (16). + */ +#define EMBER_ENCRYPTION_KEY_SIZE 16 + +/** + * @brief Size of an extended PAN identifier in bytes (8). + */ +#define EXTENDED_PAN_ID_SIZE 8 + /** * @brief EUI 64-bit ID (an IEEE address). */ @@ -451,22 +471,6 @@ enum EMBER_OUTGOING_BROADCAST }; -/** - * @brief Size of EUI64 (an IEEE address) in bytes (8). - */ -#define EUI64_SIZE 8 - -/** - * @brief Size of an encryption key in bytes (16). - */ -#define EMBER_ENCRYPTION_KEY_SIZE 16 - -/** - * @brief Size of an extended PAN identifier in bytes (8). - */ -#define EXTENDED_PAN_ID_SIZE 8 - - /** @brief Endpoint information (a ZigBee Simple Descriptor). * * This is a ZigBee Simple Descriptor and contains information @@ -755,6 +759,7 @@ enum typedef uint8_t EmberAfPluginNetworkSteeringJoiningState; +#ifdef DOXYGEN_SHOULD_SKIP_THIS enum SleepModes #else typedef uint8_t SleepModes; @@ -884,6 +889,7 @@ typedef struct { #ifdef DOXYGEN_SHOULD_SKIP_THIS enum EmberStatus #else +typedef uint8_t EmberStatus; enum #endif //DOXYGEN_SHOULD_SKIP_THIS { @@ -1833,29 +1839,7 @@ typedef struct { /** * @brief The minimum 2.4GHz 802.15.4 channel number is 11. */ -#define EMBER_MIN_802_15_4_CHANNEL_NUMBER 1 -/** - * @brief Defines the possible join states for a node. - */ -#ifdef DOXYGEN_SHOULD_SKIP_THIS -enum EmberNetworkStatus -#else -typedef uint8_t EmberNetworkStatus; -enum -#endif -{ - /** The node is not associated with a network in any way. */ - EMBER_NO_NETWORK, - /** The node is currently attempting to join a network. */ - EMBER_JOINING_NETWORK, - /** The node is joined to a network. */ - EMBER_JOINED_NETWORK, - /** The node is an end device joined to a network but its parent - is not responding. */ - EMBER_JOINED_NETWORK_NO_PARENT, - /** The node is in the process of leaving its current network. */ - EMBER_LEAVING_NETWORK -}; +#define EMBER_MIN_802_15_4_CHANNEL_NUMBER 11 /** * @brief The maximum SubGhz channel number on pages 28, 30, 31 is 26. @@ -1943,3 +1927,14 @@ enum */ #define MAIN_FUNCTION_PARAMETERS void #define MAIN_FUNCTION_ARGUMENTS + +// Stubs to just silence some compile errors +#define emberAfPrint(...) /* */ +#define emberAfPrintEnabled(...) false +#define emberAfPrintln(...) /* */ +#define emberAfPrintBuffer(...) /* */ + +// Needed by callback.h and callback-stubs.c +typedef bool boolean; + +#endif // TYPES_STUB_H From c0750c4ad547a0040e19fc17b75d12983aa8fb65 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Wed, 1 Jul 2020 14:38:48 -0400 Subject: [PATCH 04/12] Fix #includes in the imported Silicon Labs code to not include nonexistent things. There are a few categories of fixes here: * Adjusting paths to match out directory structure (which is not identical to the one Silicon Labs apps normally use). * Commenting out includes of headers that we don't think we actually need. * Hardcoding some header names that are represented by preprocessor macros in the Silicon Labs build system. --- .../wifi-echo/server/esp32/main/af-main.h | 6 +-- .../wifi-echo/server/esp32/main/af-types.h | 2 +- examples/wifi-echo/server/esp32/main/af.h | 48 +++++++++---------- .../server/esp32/main/attribute-size.c | 4 +- .../server/esp32/main/attribute-storage.c | 4 +- .../server/esp32/main/attribute-storage.h | 9 ++-- .../server/esp32/main/attribute-table.c | 2 +- .../server/esp32/main/attribute-table.h | 2 +- .../wifi-echo/server/esp32/main/client-api.h | 2 +- examples/wifi-echo/server/esp32/main/common.h | 10 ++-- examples/wifi-echo/server/esp32/main/config.h | 6 ++- .../esp32/main/gen/call-command-handler.c | 8 ++-- .../server/esp32/main/gen/callback-stub.c | 6 +-- .../server/esp32/main/gen/callback.h | 6 +-- .../server/esp32/main/gen/znet-bookkeeping.c | 6 +-- .../server/esp32/main/gen/znet-bookkeeping.h | 6 +-- .../wifi-echo/server/esp32/main/message.c | 6 +-- .../esp32/main/process-global-message.c | 22 ++++----- examples/wifi-echo/server/esp32/main/util.c | 12 ++--- examples/wifi-echo/server/esp32/main/util.h | 2 +- 20 files changed, 88 insertions(+), 81 deletions(-) diff --git a/examples/wifi-echo/server/esp32/main/af-main.h b/examples/wifi-echo/server/esp32/main/af-main.h index 63023be4a400eb..08067df576dd1e 100644 --- a/examples/wifi-echo/server/esp32/main/af-main.h +++ b/examples/wifi-echo/server/esp32/main/af-main.h @@ -40,9 +40,9 @@ #ifndef SILABS_AF_MAIN_H #define SILABS_AF_MAIN_H -#include CONFIGURATION_HEADER -#include PLATFORM_HEADER // Micro and compiler specific typedefs and macros -#include "stack/include/ember-types.h" +//#include CONFIGURATION_HEADER +//#include PLATFORM_HEADER // Micro and compiler specific typedefs and macros +//#include "stack/include/ember-types.h" #define MFG_STRING_MAX_LENGTH 16 diff --git a/examples/wifi-echo/server/esp32/main/af-types.h b/examples/wifi-echo/server/esp32/main/af-types.h index 4a05032d3d4cf3..37ef8c1a04665f 100644 --- a/examples/wifi-echo/server/esp32/main/af-types.h +++ b/examples/wifi-echo/server/esp32/main/af-types.h @@ -46,7 +46,7 @@ #ifndef SILABS_AF_API_TYPES #define SILABS_AF_API_TYPES -#include "enums.h" +#include "gen/enums.h" #ifdef EZSP_HOST #include "app/util/ezsp/ezsp-enum.h" diff --git a/examples/wifi-echo/server/esp32/main/af.h b/examples/wifi-echo/server/esp32/main/af.h index d09e775107f096..16017782369626 100644 --- a/examples/wifi-echo/server/esp32/main/af.h +++ b/examples/wifi-echo/server/esp32/main/af.h @@ -50,10 +50,10 @@ #define SILABS_AF_API // Micro and compiler specific typedefs and macros -#include PLATFORM_HEADER +//#include PLATFORM_HEADER #ifndef CONFIGURATION_HEADER - #define CONFIGURATION_HEADER "app/framework/util/config.h" + #define CONFIGURATION_HEADER "config.h" #endif #include CONFIGURATION_HEADER @@ -68,33 +68,33 @@ #include "app/util/ezsp/serial-interface.h" #else // Includes needed for ember related functions for the SoC - #include "stack/include/ember.h" +// #include "stack/include/ember.h" #endif // EZSP_HOST // HAL - hardware abstraction layer -#include "hal/hal.h" -#include "plugin/serial/serial.h" // Serial utility APIs +//#include "hal/hal.h" +//#include "plugin/serial/serial.h" // Serial utility APIs -#include "stack/include/event.h" -#include "stack/include/error.h" +//#include "stack/include/event.h" +//#include "stack/include/error.h" #include "af-types.h" -#include "app/framework/util/print.h" -#include "app/framework/util/time-util.h" -#include "af-structs.h" -#include "attribute-id.h" -#include "att-storage.h" -#include "attribute-type.h" -#include "call-command-handler.h" -#include "callback.h" -#include "client-command-macro.h" -#include "cluster-id.h" -#include "command-id.h" -#include "debug-printing.h" -#include "enums.h" -#include "print-cluster.h" -#include "app/framework/util/client-api.h" -#include "app/util/serial/command-interpreter2.h" -#include "app/framework/cli/zcl-cli.h" +//#include "app/framework/util/print.h" +//#include "app/framework/util/time-util.h" +#include "gen/af-structs.h" +#include "gen/attribute-id.h" +#include "gen/att-storage.h" +#include "gen/attribute-type.h" +#include "gen/call-command-handler.h" +#include "gen/callback.h" +#include "gen/client-command-macro.h" +#include "gen/cluster-id.h" +#include "gen/command-id.h" +#include "gen/debug-printing.h" +#include "gen/enums.h" +#include "gen/print-cluster.h" +#include "client-api.h" +//#include "app/util/serial/command-interpreter2.h" +//#include "app/framework/cli/zcl-cli.h" /** @name Attribute Storage */ // @{ diff --git a/examples/wifi-echo/server/esp32/main/attribute-size.c b/examples/wifi-echo/server/esp32/main/attribute-size.c index 6a737b0ebe8a2c..14982a55bf4d29 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-size.c +++ b/examples/wifi-echo/server/esp32/main/attribute-size.c @@ -37,13 +37,13 @@ ******************************************************************************* ******************************************************************************/ -#include PLATFORM_HEADER +//#include PLATFORM_HEADER #include "af.h" static const uint8_t attributeSizes[] = { -#include "attribute-size.h" +#include "gen/attribute-size.h" }; uint8_t emberAfGetDataSize(uint8_t dataType) diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.c b/examples/wifi-echo/server/esp32/main/attribute-storage.c index 937b7deea31d0e..72f1f8ed94efac 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-storage.c +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.c @@ -37,11 +37,11 @@ ******************************************************************************* ******************************************************************************/ -#include "app/framework/include/af.h" +#include "af.h" #include "attribute-storage.h" #include "common.h" -#include "znet-bookkeeping.h" +#include "gen/znet-bookkeeping.h" //------------------------------------------------------------------------------ // Globals diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.h b/examples/wifi-echo/server/esp32/main/attribute-storage.h index b27c4b3d611d2a..4fad79592b88d4 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-storage.h +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.h @@ -40,11 +40,11 @@ #ifndef __AF_ATTRIBUTE_STORAGE__ #define __AF_ATTRIBUTE_STORAGE__ -#include PLATFORM_HEADER -#include "../include/af.h" +//#include PLATFORM_HEADER +#include "af.h" #if !defined (EMBER_SCRIPTED_TEST) - #include "att-storage.h" + #include "gen/att-storage.h" #endif #if !defined(ATTRIBUTE_STORAGE_CONFIGURATION) && defined(EMBER_TEST) @@ -56,7 +56,8 @@ // attribute data structures. If it is missing // we use the provider sample. #ifndef ATTRIBUTE_STORAGE_CONFIGURATION - #error "Must define ATTRIBUTE_STORAGE_CONFIGURATION to specify the App. Builder default attributes file." +// #error "Must define ATTRIBUTE_STORAGE_CONFIGURATION to specify the App. Builder default attributes file." + #include "gen/endpoint_config.h" #else #include ATTRIBUTE_STORAGE_CONFIGURATION #endif diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.c b/examples/wifi-echo/server/esp32/main/attribute-table.c index 65dd532f2dd72d..bbde736632b832 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-table.c +++ b/examples/wifi-echo/server/esp32/main/attribute-table.c @@ -47,7 +47,7 @@ // for pulling in defines dealing with EITHER server or client #include "af-main.h" -#include "enums.h" +#include "gen/enums.h" //------------------------------------------------------------------------------ diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.h b/examples/wifi-echo/server/esp32/main/attribute-table.h index ec93dc5cfd79e8..9943ee6641bc62 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-table.h +++ b/examples/wifi-echo/server/esp32/main/attribute-table.h @@ -41,7 +41,7 @@ #ifndef ZCL_UTIL_ATTRIBUTE_TABLE_H #define ZCL_UTIL_ATTRIBUTE_TABLE_H -#include "../include/af.h" +#include "af.h" #define ZCL_NULL_ATTRIBUTE_TABLE_INDEX 0xFFFF diff --git a/examples/wifi-echo/server/esp32/main/client-api.h b/examples/wifi-echo/server/esp32/main/client-api.h index a1ff750554dc3d..e62019e41605b8 100644 --- a/examples/wifi-echo/server/esp32/main/client-api.h +++ b/examples/wifi-echo/server/esp32/main/client-api.h @@ -183,7 +183,7 @@ extern EmberApsFrame *emAfCommandApsFrame; #endif // Generated macros. -#include "client-command-macro.h" +#include "gen/client-command-macro.h" #define emberAfAppendToExternalBuffer(...) emberAfPutBlockInResp(__VA_ARGS__) diff --git a/examples/wifi-echo/server/esp32/main/common.h b/examples/wifi-echo/server/esp32/main/common.h index 09924857c2d2cd..92cd0a8b91049e 100644 --- a/examples/wifi-echo/server/esp32/main/common.h +++ b/examples/wifi-echo/server/esp32/main/common.h @@ -42,11 +42,11 @@ #define SILABS_COMMON_H // App framework -#include "app/framework/include/af.h" -#include "app/framework/util/util.h" -#include "app/framework/util/time-util.h" -#include "app/framework/util/attribute-table.h" -#include "app/framework/util/attribute-storage.h" +#include "af.h" +#include "util.h" +#include "time-util.h" +#include "attribute-table.h" +#include "attribute-storage.h" // the variables used to setup and send responses to cluster messages extern EmberApsFrame emberAfResponseApsFrame; diff --git a/examples/wifi-echo/server/esp32/main/config.h b/examples/wifi-echo/server/esp32/main/config.h index 3f00903d4d223d..4f5a265fd995ec 100644 --- a/examples/wifi-echo/server/esp32/main/config.h +++ b/examples/wifi-echo/server/esp32/main/config.h @@ -66,10 +66,14 @@ // ZA_GENERATED_HEADER is defined in the project file #ifdef ZA_GENERATED_HEADER #include ZA_GENERATED_HEADER +#else + #include "gen/gen_config.h" #endif #ifdef ATTRIBUTE_STORAGE_CONFIGURATION #include ATTRIBUTE_STORAGE_CONFIGURATION +#else + #include "gen/endpoint_config.h" #endif // ******************************************************************* // pre-defined Devices @@ -100,7 +104,7 @@ // This file determines the security profile used, and from that various // other security parameters. -#include "app/framework/security/security-config.h" +// #include "app/framework/security/security-config.h" // ******************************************************************* // Application configuration of RAM for cluster usage diff --git a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c index 28fd312db58b01..e5c460890b6556 100644 --- a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c @@ -40,7 +40,7 @@ -#include PLATFORM_HEADER +// #include PLATFORM_HEADER #ifdef EZSP_HOST // Includes needed for ember related functions for the EZSP host #include "stack/include/error.h" @@ -51,10 +51,12 @@ #include "app/util/ezsp/serial-interface.h" #else // Includes needed for ember related functions for the EM250 -#include "stack/include/ember.h" +// #include "stack/include/ember.h" #endif // EZSP_HOST -#include "app/framework/util/util.h" +#include + +#include "../util.h" #include "af-structs.h" #include "call-command-handler.h" #include "command-id.h" diff --git a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c index d76cd04d79c441..e4c09f671ad178 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -38,9 +38,9 @@ // This c file provides stubs for all callbacks. These stubs // will be used in the case where user defined implementations // of the callbacks have not been provided. -#include "app/framework/include/af.h" -#include "hal/hal.h" -#include EMBER_AF_API_NETWORK_STEERING +#include "../af.h" +//#include "hal/hal.h" +//#include EMBER_AF_API_NETWORK_STEERING diff --git a/examples/wifi-echo/server/esp32/main/gen/callback.h b/examples/wifi-echo/server/esp32/main/gen/callback.h index 0d72b17d7c6a35..9ca0bf04eeca56 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback.h +++ b/examples/wifi-echo/server/esp32/main/gen/callback.h @@ -48,9 +48,9 @@ */ -#include "app/framework/include/af-types.h" -#include "hal/hal.h" -#include EMBER_AF_API_NETWORK_STEERING +#include "../af-types.h" +//#include "hal/hal.h" +//#include EMBER_AF_API_NETWORK_STEERING diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c index 0e788a1236f3fd..41e313d6fdabab 100644 --- a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c @@ -35,9 +35,9 @@ // // -#include PLATFORM_HEADER -#include CONFIGURATION_HEADER -#include "af.h" +//#include PLATFORM_HEADER +//#include CONFIGURATION_HEADER +#include "../af.h" // Init function declarations. void emberAfMainInitCallback(void); // Global diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h index bad66db1eaab61..18aa71caadf577 100644 --- a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h @@ -40,9 +40,9 @@ #define SILABS_ZNET_BOOKKEEPING_H -#include PLATFORM_HEADER -#include CONFIGURATION_HEADER -#include "af.h" +//#include PLATFORM_HEADER +//#include CONFIGURATION_HEADER +#include "../af.h" void emAfInit(void); diff --git a/examples/wifi-echo/server/esp32/main/message.c b/examples/wifi-echo/server/esp32/main/message.c index f21b1a9a7f2fbf..6aa39574b68c16 100644 --- a/examples/wifi-echo/server/esp32/main/message.c +++ b/examples/wifi-echo/server/esp32/main/message.c @@ -38,9 +38,9 @@ ******************************************************************************* ******************************************************************************/ -#include "app/framework/include/af.h" -#include "app/framework/util/util.h" -#include "app/framework/util/config.h" +#include "af.h" +#include "util.h" +#include "config.h" //------------------------------------------------------------------------------ diff --git a/examples/wifi-echo/server/esp32/main/process-global-message.c b/examples/wifi-echo/server/esp32/main/process-global-message.c index cb790b1ef264f2..f27f8a3e870595 100644 --- a/examples/wifi-echo/server/esp32/main/process-global-message.c +++ b/examples/wifi-echo/server/esp32/main/process-global-message.c @@ -37,18 +37,18 @@ ******************************************************************************* ******************************************************************************/ -#include "../include/af.h" +#include "af.h" #include "common.h" -#include "../plugin/ias-zone-client/ias-zone-client.h" -#include "../plugin/key-establishment/key-establishment.h" -#include "../plugin/smart-energy-registration/smart-energy-registration.h" -#include "../plugin/trust-center-keepalive/trust-center-keepalive.h" -#include "../plugin/test-harness/test-harness.h" -#ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS - #include "../plugin/wwah-server-silabs/wwah-server-silabs.h" -#endif -#include "../plugin/simple-metering-server/simple-metering-server.h" -#include "znet-bookkeeping.h" // emAfRetrieveAttributeAndCraftResponse +//#include "../plugin/ias-zone-client/ias-zone-client.h" +//#include "../plugin/key-establishment/key-establishment.h" +//#include "../plugin/smart-energy-registration/smart-energy-registration.h" +//#include "../plugin/trust-center-keepalive/trust-center-keepalive.h" +//#include "../plugin/test-harness/test-harness.h" +//#ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS +// #include "../plugin/wwah-server-silabs/wwah-server-silabs.h" +//#endif +//#include "../plugin/simple-metering-server/simple-metering-server.h" +#include "gen/znet-bookkeeping.h" // emAfRetrieveAttributeAndCraftResponse #ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ #include "app/framework/plugin/comms-hub-function-sub-ghz/comms-hub-function-sub-ghz.h" diff --git a/examples/wifi-echo/server/esp32/main/util.c b/examples/wifi-echo/server/esp32/main/util.c index e6af4298a7f525..4fb25026de14f2 100644 --- a/examples/wifi-echo/server/esp32/main/util.c +++ b/examples/wifi-echo/server/esp32/main/util.c @@ -38,14 +38,14 @@ ******************************************************************************* ******************************************************************************/ -#include "../include/af.h" +#include "af.h" #include "af-main.h" #include "common.h" -#include "../plugin/time-server/time-server.h" -#include "app/framework/util/af-event.h" -#include "app/framework/util/time-util.h" -#include "znet-bookkeeping.h" -#include "hal/micro/crc.h" +//#include "../plugin/time-server/time-server.h" +//#include "app/framework/util/af-event.h" +//#include "app/framework/util/time-util.h" +#include "gen/znet-bookkeeping.h" +//#include "hal/micro/crc.h" //------------------------------------------------------------------------------ // Forward Declarations diff --git a/examples/wifi-echo/server/esp32/main/util.h b/examples/wifi-echo/server/esp32/main/util.h index 01f75e07a8384a..949a63a6c09c9e 100644 --- a/examples/wifi-echo/server/esp32/main/util.h +++ b/examples/wifi-echo/server/esp32/main/util.h @@ -81,7 +81,7 @@ extern const EmberAfClusterName zclClusterNames[]; #define ZCL_NULL_CLUSTER_ID 0xFFFF -#include "../include/af.h" +#include "af.h" // Override APS retry: 0 - don't touch, 1 - always set, 2 - always unset typedef enum { From 324831202ba961c02023f4354156cb920f0e2c5c Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 2 Jul 2020 14:06:04 -0400 Subject: [PATCH 05/12] Include various missing headers to allow the Silicon Labs code to compile. --- examples/wifi-echo/server/esp32/main/af-main.h | 2 ++ examples/wifi-echo/server/esp32/main/af-types.h | 5 +++++ examples/wifi-echo/server/esp32/main/config.h | 3 +++ examples/wifi-echo/server/esp32/main/gen/callback-stub.c | 1 + 4 files changed, 11 insertions(+) diff --git a/examples/wifi-echo/server/esp32/main/af-main.h b/examples/wifi-echo/server/esp32/main/af-main.h index 08067df576dd1e..367c90f2a32b7f 100644 --- a/examples/wifi-echo/server/esp32/main/af-main.h +++ b/examples/wifi-echo/server/esp32/main/af-main.h @@ -40,6 +40,8 @@ #ifndef SILABS_AF_MAIN_H #define SILABS_AF_MAIN_H +#include "af-types.h" + //#include CONFIGURATION_HEADER //#include PLATFORM_HEADER // Micro and compiler specific typedefs and macros //#include "stack/include/ember-types.h" diff --git a/examples/wifi-echo/server/esp32/main/af-types.h b/examples/wifi-echo/server/esp32/main/af-types.h index 37ef8c1a04665f..b8fee1b2ac585f 100644 --- a/examples/wifi-echo/server/esp32/main/af-types.h +++ b/examples/wifi-echo/server/esp32/main/af-types.h @@ -46,7 +46,12 @@ #ifndef SILABS_AF_API_TYPES #define SILABS_AF_API_TYPES +#include // For bool +#include // For various uint*_t types +#include // For NULL. + #include "gen/enums.h" +#include "types_stub.h" // For various types. #ifdef EZSP_HOST #include "app/util/ezsp/ezsp-enum.h" diff --git a/examples/wifi-echo/server/esp32/main/config.h b/examples/wifi-echo/server/esp32/main/config.h index 4f5a265fd995ec..25172346ec5598 100644 --- a/examples/wifi-echo/server/esp32/main/config.h +++ b/examples/wifi-echo/server/esp32/main/config.h @@ -75,6 +75,9 @@ #else #include "gen/endpoint_config.h" #endif + +#include "gen/gen_tokens.h" // For GENERATED_TOKEN_LOADER/SAVER macros + // ******************************************************************* // pre-defined Devices // diff --git a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c index e4c09f671ad178..ce6bffe1e4ac8e 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -38,6 +38,7 @@ // This c file provides stubs for all callbacks. These stubs // will be used in the case where user defined implementations // of the callbacks have not been provided. +#include #include "../af.h" //#include "hal/hal.h" //#include EMBER_AF_API_NETWORK_STEERING From 2d08c99c2ca9f4e5d539052ec6e1918f40ba4db4 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Wed, 8 Jul 2020 16:38:32 -0400 Subject: [PATCH 06/12] Comment or ifdef out various calls to Silicon Labs functions we are not pulling in. For some of these we are not even pulling in the declaration. For some, we have a declaration, but no definition. At first glance, all of these are either there to solve problems that we will solve in a different way in CHIP, or the callsites are in code that CHIP is almost certainly not going to use. --- .../server/esp32/main/attribute-storage.c | 28 ++++++------- .../server/esp32/main/attribute-table.c | 2 +- .../wifi-echo/server/esp32/main/message.c | 2 +- .../esp32/main/process-global-message.c | 2 +- examples/wifi-echo/server/esp32/main/util.c | 41 +++++++++++++------ 5 files changed, 46 insertions(+), 29 deletions(-) diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.c b/examples/wifi-echo/server/esp32/main/attribute-storage.c index 72f1f8ed94efac..ada4cabc8b7a76 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-storage.c +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.c @@ -200,9 +200,9 @@ void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, emberAfFindClusterFunction(cluster, CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION); if (f != NULL) { - emberAfPushEndpointNetworkIndex(endpoint); + //emberAfPushEndpointNetworkIndex(endpoint); ((EmberAfDefaultResponseFunction)f)(endpoint, commandId, status); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } } } @@ -247,14 +247,14 @@ void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, emberAfFindClusterFunction(cluster, CLUSTER_MASK_MESSAGE_SENT_FUNCTION); if (f != NULL) { - emberAfPushEndpointNetworkIndex(apsFrame->sourceEndpoint); + //emberAfPushEndpointNetworkIndex(apsFrame->sourceEndpoint); ((EmberAfMessageSentFunction)f)(type, indexOrDestination, apsFrame, msgLen, message, status); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } } } @@ -296,20 +296,20 @@ void emAfClusterAttributeChangedCallback(uint8_t endpoint, emberAfFindClusterFunction(cluster, CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION); if (f != NULL) { - emberAfPushEndpointNetworkIndex(endpoint); + //emberAfPushEndpointNetworkIndex(endpoint); ((EmberAfClusterAttributeChangedCallback)f)(endpoint, attributeId); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } } else { EmberAfGenericClusterFunction f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_MANUFACTURER_SPECIFIC_ATTRIBUTE_CHANGED_FUNCTION); if (f != NULL) { - emberAfPushEndpointNetworkIndex(endpoint); + //emberAfPushEndpointNetworkIndex(endpoint); ((EmberAfManufacturerSpecificClusterAttributeChangedCallback)f)(endpoint, attributeId, manufacturerCode); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } } } @@ -338,13 +338,13 @@ EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, emberAfFindClusterFunction(cluster, CLUSTER_MASK_PRE_ATTRIBUTE_CHANGED_FUNCTION); if (f != NULL) { - emberAfPushEndpointNetworkIndex(endpoint); + //emberAfPushEndpointNetworkIndex(endpoint); status = ((EmberAfClusterPreAttributeChangedCallback)f)(endpoint, attributeId, attributeType, size, value); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } } return status; @@ -355,7 +355,7 @@ static void initializeEndpoint(EmberAfDefinedEndpoint* definedEndpoint) { uint8_t clusterIndex; EmberAfEndpointType* epType = definedEndpoint->endpointType; - emberAfPushEndpointNetworkIndex(definedEndpoint->endpoint); + //emberAfPushEndpointNetworkIndex(definedEndpoint->endpoint); for ( clusterIndex = 0; clusterIndex < epType->clusterCount; clusterIndex++ ) { @@ -367,7 +367,7 @@ static void initializeEndpoint(EmberAfDefinedEndpoint* definedEndpoint) ((EmberAfInitFunction)f)(definedEndpoint->endpoint); } } - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } // Calls the init functions. @@ -1073,7 +1073,7 @@ void emberAfResetAttributes(uint8_t endpoint) void emAfLoadAttributeDefaults(uint8_t endpoint, bool writeTokens) { - uint8_t ep, clusterI, curNetwork = emberGetCurrentNetwork(); + uint8_t ep, clusterI, curNetwork = 0 /* emberGetCurrentNetwork() */; uint16_t attr; uint8_t *ptr; uint8_t epCount = emberAfEndpointCount(); @@ -1101,7 +1101,7 @@ void emAfLoadAttributeDefaults(uint8_t endpoint, bool writeTokens) // conditionally manually reset the watchdog. 300 sounds like a good // magic number for now. if (cluster->attributeCount > 300) { - halResetWatchdog(); + // halResetWatchdog(); } for ( attr = 0; attr < cluster->attributeCount; attr++) { EmberAfAttributeMetadata *am = &(cluster->attributes[attr]); diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.c b/examples/wifi-echo/server/esp32/main/attribute-table.c index bbde736632b832..1b78617fa34fda 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-table.c +++ b/examples/wifi-echo/server/esp32/main/attribute-table.c @@ -399,7 +399,7 @@ void emberAfPrintAttributeTable(void) // Depending on user config, this loop can take a very long time to // run and watchdog reset will kick in. As a workaround, we'll // manually reset the watchdog. - halResetWatchdog(); + // halResetWatchdog(); emberAfAttributesPrint("%2x / %p / %2x / ", cluster->clusterId, diff --git a/examples/wifi-echo/server/esp32/main/message.c b/examples/wifi-echo/server/esp32/main/message.c index 6aa39574b68c16..aef30d2b38b6b9 100644 --- a/examples/wifi-echo/server/esp32/main/message.c +++ b/examples/wifi-echo/server/esp32/main/message.c @@ -69,7 +69,7 @@ void emberAfClearResponseData(void) emberAfResponseType = ZCL_UTIL_RESP_NORMAL; // To prevent accidentally sending to someone else, // set the destination to ourselves. - emberAfResponseDestination = emberAfGetNodeId(); + emberAfResponseDestination = 0 /* emberAfGetNodeId() */; MEMSET(appResponseData, 0, EMBER_AF_RESPONSE_BUFFER_LEN); appResponseLength = 0; MEMSET(&emberAfResponseApsFrame, 0, sizeof(EmberApsFrame)); diff --git a/examples/wifi-echo/server/esp32/main/process-global-message.c b/examples/wifi-echo/server/esp32/main/process-global-message.c index f27f8a3e870595..d1b14e3cb8cc93 100644 --- a/examples/wifi-echo/server/esp32/main/process-global-message.c +++ b/examples/wifi-echo/server/esp32/main/process-global-message.c @@ -514,7 +514,7 @@ bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd) == EMBER_ZCL_STATUS_SUCCESS) && (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_UTC_TIME_ATTRIBUTE_TYPE)) { - emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen)); + // emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen)); emberAfDebugPrintln("time sync ok, time: %4x", emberAfGetCurrentTime()); emAfSyncingTime = false; } diff --git a/examples/wifi-echo/server/esp32/main/util.c b/examples/wifi-echo/server/esp32/main/util.c index 4fb25026de14f2..35d02ee0f1267f 100644 --- a/examples/wifi-echo/server/esp32/main/util.c +++ b/examples/wifi-echo/server/esp32/main/util.c @@ -254,21 +254,26 @@ void emberAfInit(void) #endif for (i = 0; i < EMBER_SUPPORTED_NETWORKS; i++) { - emberAfPushNetworkIndex(i); + // FIXME: Do we need to support more than one network? + //emberAfPushNetworkIndex(i); emberAfInitializeAttributes(EMBER_BROADCAST_ENDPOINT); - emberAfPopNetworkIndex(); + //emberAfPopNetworkIndex(); } MEMSET(afDeviceEnabled, true, emberAfEndpointCount()); // Set up client API buffer. + // FIXME: Is this needed? appResponseData seems unused in the code we pulled + // in so far. +#if 0 emberAfSetExternalBuffer(appResponseData, EMBER_AF_RESPONSE_BUFFER_LEN, &appResponseLength, &emberAfResponseApsFrame); +#endif // initialize event management system - emAfInitEvents(); + //emAfInitEvents(); #ifdef EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS @@ -300,8 +305,10 @@ void emberAfStackDown(void) // (Issue 77101) Also don't clear the table if the stack has gone down as a // a result of losing its parent or some other transient state where a future // rejoin is expected to get us back online. - if (emberStackIsPerformingRejoin() == false - && emberNetworkState() == EMBER_NO_NETWORK) { + if (false + // emberStackIsPerformingRejoin() == false + // && emberNetworkState() == EMBER_NO_NETWORK + ) { // the report table should be cleared when the stack comes down. // going to a new network means new report devices should be discovered. // if the table isnt cleared the device keeps trying to send messages. @@ -498,7 +505,7 @@ bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, return false; } returnCmd->interPanHeader = interPanHeader; - returnCmd->networkIndex = emberGetCurrentNetwork(); + // returnCmd->networkIndex = emberGetCurrentNetwork(); return true; } @@ -730,19 +737,27 @@ EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; } else if (emberAfResponseDestination < EMBER_BROADCAST_ADDRESS) { label = 'U'; +#if 0 status = emberAfSendUnicastWithCallback(EMBER_OUTGOING_DIRECT, emberAfResponseDestination, &emberAfResponseApsFrame, appResponseLength, appResponseData, callback); +#else + status = EMBER_SUCCESS; +#endif } else { label = 'B'; +#if 0 status = emberAfSendBroadcastWithCallback(emberAfResponseDestination, &emberAfResponseApsFrame, appResponseLength, appResponseData, callback); +#else + status = EMBER_SUCCESS; +#endif } UNUSED_VAR(label); emberAfDebugPrintln("T%4x:TX (%p) %ccast 0x%x%p", @@ -958,10 +973,10 @@ uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, destination = indexOrDestination; break; case EMBER_OUTGOING_VIA_ADDRESS_TABLE: - destination = emberGetAddressTableRemoteNodeId(indexOrDestination); + // destination = emberGetAddressTableRemoteNodeId(indexOrDestination); break; case EMBER_OUTGOING_VIA_BINDING: - destination = emberGetBindingRemoteNodeId(indexOrDestination); + // destination = emberGetBindingRemoteNodeId(indexOrDestination); break; case EMBER_OUTGOING_MULTICAST: // APS multicast messages include the two-byte group id and exclude the @@ -1149,7 +1164,7 @@ EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl *controls, if (index == 0xFF) { return EMBER_INVALID_ENDPOINT; } - emberEventControlSetInactive(controls[index]); + //emberEventControlSetInactive(controls[index]); return EMBER_SUCCESS; } @@ -1157,7 +1172,7 @@ bool emberAfEndpointEventControlGetActive(EmberEventControl *controls, uint8_t endpoint) { uint8_t index = emberAfIndexFromEndpoint(endpoint); - return (index != 0xFF && emberEventControlGetActive(controls[index])); + return (index != 0xFF && false /*emberEventControlGetActive(controls[index])*/); } EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, @@ -1167,7 +1182,7 @@ EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, if (index == 0xFF) { return EMBER_INVALID_ENDPOINT; } - emberEventControlSetActive(controls[index]); + //emberEventControlSetActive(controls[index]); return EMBER_SUCCESS; } @@ -1251,7 +1266,9 @@ uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initial uint16_t i; uint32_t crc32 = initialValue; for (i = 0; i < length; i++) { - crc32 = halCommonCrc32(pbuffer[i], crc32); + // Crash so we don't reach this code by accident. + *(int*)0 = 5; + // crc32 = halCommonCrc32(pbuffer[i], crc32); } return crc32; } From 857e4f67d0e54477ef9c43383bd0d737f1ede063 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Fri, 3 Jul 2020 02:55:20 -0400 Subject: [PATCH 07/12] Copy declaration of emberAfPluginOnOffClusterServerPostInitCallback from the zll-color-light sample app in the SiLabs ZCL code. --- examples/wifi-echo/server/esp32/main/gen/callback.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/examples/wifi-echo/server/esp32/main/gen/callback.h b/examples/wifi-echo/server/esp32/main/gen/callback.h index 9ca0bf04eeca56..dcbd4f35d7fecb 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback.h +++ b/examples/wifi-echo/server/esp32/main/gen/callback.h @@ -3592,6 +3592,14 @@ bool emberAfOnOffClusterToggleCallback(void); EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange); +/** @brief On/off Cluster Server Post Init + * + * Following resolution of the On/Off state at startup for this endpoint, perform any + * additional initialization needed; e.g., synchronize hardware state. + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPluginOnOffClusterServerPostInitCallback(uint8_t endpoint); /** @} END On/off Cluster Callbacks */ From 305324168d6f8fd1ccbb34f1c219b55768ef5c7b Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Wed, 15 Jul 2020 00:55:09 -0400 Subject: [PATCH 08/12] Restyle the Silicon Labs files to CHIP style --- .../wifi-echo/server/esp32/main/af-main.h | 98 +- .../wifi-echo/server/esp32/main/af-types.h | 2151 +-- examples/wifi-echo/server/esp32/main/af.h | 555 +- .../server/esp32/main/attribute-size.c | 79 +- .../server/esp32/main/attribute-storage.c | 1606 +-- .../server/esp32/main/attribute-storage.h | 166 +- .../server/esp32/main/attribute-table.c | 1107 +- .../server/esp32/main/attribute-table.h | 64 +- .../wifi-echo/server/esp32/main/client-api.h | 37 +- examples/wifi-echo/server/esp32/main/common.h | 19 +- examples/wifi-echo/server/esp32/main/config.h | 163 +- .../server/esp32/main/gen/af-structs.h | 515 +- .../server/esp32/main/gen/att-storage.h | 4 - .../server/esp32/main/gen/attribute-id.h | 7304 +++++----- .../server/esp32/main/gen/attribute-size.h | 31 +- .../server/esp32/main/gen/attribute-type.h | 116 +- .../esp32/main/gen/call-command-handler.c | 138 +- .../esp32/main/gen/call-command-handler.h | 3 +- .../server/esp32/main/gen/callback-stub.c | 981 +- .../server/esp32/main/gen/callback.h | 9078 ++++-------- .../esp32/main/gen/client-command-macro.h | 11936 +++++----------- .../server/esp32/main/gen/cluster-id.h | 217 +- .../server/esp32/main/gen/command-id.h | 1052 +- .../server/esp32/main/gen/debug-printing.h | 1933 ++- .../server/esp32/main/gen/endpoint_config.h | 122 +- .../wifi-echo/server/esp32/main/gen/enums.h | 3717 ++--- .../server/esp32/main/gen/gen_config.h | 91 +- .../server/esp32/main/gen/gen_tokens.h | 19 +- .../server/esp32/main/gen/print-cluster.h | 803 +- .../server/esp32/main/gen/znet-bookkeeping.c | 67 +- .../server/esp32/main/gen/znet-bookkeeping.h | 12 +- .../wifi-echo/server/esp32/main/message.c | 321 +- examples/wifi-echo/server/esp32/main/on-off.c | 368 +- .../esp32/main/process-cluster-message.c | 91 +- .../esp32/main/process-global-message.c | 1093 +- .../wifi-echo/server/esp32/main/time-util.h | 26 +- .../wifi-echo/server/esp32/main/types_stub.h | 2802 ++-- examples/wifi-echo/server/esp32/main/util.c | 1859 +-- examples/wifi-echo/server/esp32/main/util.h | 122 +- 39 files changed, 21461 insertions(+), 29405 deletions(-) diff --git a/examples/wifi-echo/server/esp32/main/af-main.h b/examples/wifi-echo/server/esp32/main/af-main.h index 367c90f2a32b7f..20ea4cfa18f23f 100644 --- a/examples/wifi-echo/server/esp32/main/af-main.h +++ b/examples/wifi-echo/server/esp32/main/af-main.h @@ -31,11 +31,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file * @brief ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef SILABS_AF_MAIN_H #define SILABS_AF_MAIN_H @@ -48,23 +49,23 @@ #define MFG_STRING_MAX_LENGTH 16 -typedef struct { - EmberAfMessageSentFunction callback; - uint8_t tag; +typedef struct +{ + EmberAfMessageSentFunction callback; + uint8_t tag; } CallbackTableEntry; #if defined(EZSP_HOST) -bool emberAfMemoryByteCompare(const uint8_t* pointer, uint8_t count, uint8_t byteValue); +bool emberAfMemoryByteCompare(const uint8_t * pointer, uint8_t count, uint8_t byteValue); #else -bool emMemoryByteCompare(const uint8_t *bytes, uint8_t count, uint8_t target); +bool emMemoryByteCompare(const uint8_t * bytes, uint8_t count, uint8_t target); -#define emberAfMemoryByteCompare(pointer, count, byteValue) \ - emMemoryByteCompare((pointer), (count), (byteValue)) +#define emberAfMemoryByteCompare(pointer, count, byteValue) emMemoryByteCompare((pointer), (count), (byteValue)) #endif // returnData must be MFG_STRING_MAX_LENGTH in length and // is NOT expected to be NULL terminated (could be though) -void emberAfGetMfgString(uint8_t* returnData); +void emberAfGetMfgString(uint8_t * returnData); // Functions common to both SOC and Host versions of the application. void emAfInitializeMessageSentCallbackArray(void); @@ -74,36 +75,26 @@ EmberAfCbkeKeyEstablishmentSuite emberAfIsFullSmartEnergySecurityPresent(void); #if defined(EZSP_HOST) void emAfClearNetworkCache(uint8_t networkIndex); #else - #define emAfClearNetworkCache(index) -uint8_t emAfCopyMessageIntoRamBuffer(EmberMessageBuffer message, - uint8_t *buffer, - uint16_t bufLen); +#define emAfClearNetworkCache(index) +uint8_t emAfCopyMessageIntoRamBuffer(EmberMessageBuffer message, uint8_t * buffer, uint16_t bufLen); #endif #if defined EZSP_HOST // utility for setting an EZSP config value and printing the result -EzspStatus emberAfSetEzspConfigValue(EzspConfigId configId, - uint16_t value, - const char * configIdName); +EzspStatus emberAfSetEzspConfigValue(EzspConfigId configId, uint16_t value, const char * configIdName); // utility for setting an EZSP policy and printing the result -EzspStatus emberAfSetEzspPolicy(EzspPolicyId policyId, - EzspDecisionId decisionId, - const char * policyName, +EzspStatus emberAfSetEzspPolicy(EzspPolicyId policyId, EzspDecisionId decisionId, const char * policyName, const char * decisionName); // utility for setting an EZSP value and printing the result -EzspStatus emberAfSetEzspValue(EzspValueId valueId, - uint8_t valueLength, - uint8_t *value, - const char * valueName); +EzspStatus emberAfSetEzspValue(EzspValueId valueId, uint8_t valueLength, uint8_t * value, const char * valueName); bool emberAfNcpNeedsReset(void); #endif // EZSP_HOST -void emAfPrintStatus(const char * task, - EmberStatus status); +void emAfPrintStatus(const char * task, EmberStatus status); uint8_t emberAfGetSecurityLevel(void); uint8_t emberAfGetKeyTableSize(void); @@ -118,49 +109,26 @@ uint8_t emberAfGetSleepyMulticastConfig(void); uint8_t emAfGetPacketBufferFreeCount(void); uint8_t emAfGetPacketBufferTotalCount(void); -EmberStatus emberAfGetSourceRouteTableEntry( - uint8_t index, - EmberNodeId *destination, - uint8_t *closerIndex); +EmberStatus emberAfGetSourceRouteTableEntry(uint8_t index, EmberNodeId * destination, uint8_t * closerIndex); uint8_t emberAfGetSourceRouteTableTotalSize(void); uint8_t emberAfGetSourceRouteTableFilledSize(void); -EmberStatus emberAfGetChildData(uint8_t index, - EmberChildData* childData); +EmberStatus emberAfGetChildData(uint8_t index, EmberChildData * childData); void emAfCliVersionCommand(void); -EmberStatus emAfPermitJoin(uint8_t duration, - bool broadcastMgmtPermitJoin); +EmberStatus emAfPermitJoin(uint8_t duration, bool broadcastMgmtPermitJoin); void emAfStopSmartEnergyStartup(void); -bool emAfProcessZdo(EmberNodeId sender, - EmberApsFrame* apsFrame, - uint8_t* message, - uint16_t length); - -void emAfIncomingMessageHandler(EmberIncomingMessageType type, - EmberApsFrame *apsFrame, - uint8_t lastHopLqi, - int8_t lastHopRssi, - uint16_t messageLength, - uint8_t *messageContents); -EmberStatus emAfSend(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint8_t messageLength, - uint8_t *message, - uint8_t *messageTag, - EmberNodeId alias, - uint8_t sequence); -void emAfMessageSentHandler(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - EmberStatus status, - uint16_t messageLength, - uint8_t *messageContents, - uint8_t messageTag); +bool emAfProcessZdo(EmberNodeId sender, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length); + +void emAfIncomingMessageHandler(EmberIncomingMessageType type, EmberApsFrame * apsFrame, uint8_t lastHopLqi, int8_t lastHopRssi, + uint16_t messageLength, uint8_t * messageContents); +EmberStatus emAfSend(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, uint8_t messageLength, + uint8_t * message, uint8_t * messageTag, EmberNodeId alias, uint8_t sequence); +void emAfMessageSentHandler(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + EmberStatus status, uint16_t messageLength, uint8_t * messageContents, uint8_t messageTag); void emAfStackStatusHandler(EmberStatus status); void emAfNetworkInit(void); @@ -169,9 +137,9 @@ void emAfNetworkInit(void); // at reboot. This allows us to call it manually later and prevent the node // from immediately coming back up on the network after reboot. #ifdef EMBER_AF_TC_SWAP_OUT_TEST - #define EM_AF_NETWORK_INIT() +#define EM_AF_NETWORK_INIT() #else - #define EM_AF_NETWORK_INIT() emAfNetworkInit() +#define EM_AF_NETWORK_INIT() emAfNetworkInit() #endif #define emberAfCopyBigEndianEui64Argument emberCopyBigEndianEui64Argument @@ -179,7 +147,7 @@ void emAfScheduleFindAndRejoinEvent(void); extern const EmberEUI64 emberAfNullEui64; -void emberAfFormatMfgString(uint8_t* mfgString); +void emberAfFormatMfgString(uint8_t * mfgString); extern bool emberAfPrintReceivedMessages; @@ -188,7 +156,7 @@ void emAfPrintEzspEndpointFlags(uint8_t endpoint); // Old names #define emberAfMoveInProgress() emberAfMoveInProgressCallback() -#define emberAfStartMove() emberAfStartMoveCallback() -#define emberAfStopMove() emberAfStopMoveCallback() +#define emberAfStartMove() emberAfStartMoveCallback() +#define emberAfStopMove() emberAfStopMoveCallback() #endif // SILABS_AF_MAIN_H diff --git a/examples/wifi-echo/server/esp32/main/af-types.h b/examples/wifi-echo/server/esp32/main/af-types.h index b8fee1b2ac585f..5b1c6a464ee20e 100644 --- a/examples/wifi-echo/server/esp32/main/af-types.h +++ b/examples/wifi-echo/server/esp32/main/af-types.h @@ -31,11 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief The include file for all the types for Ember ApplicationFramework + * @brief The include file for all the types for Ember + *ApplicationFramework ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ /** @addtogroup aftypes Zigbee Application Framework Types Reference * This documentation describes the types used by the Zigbee @@ -46,9 +48,9 @@ #ifndef SILABS_AF_API_TYPES #define SILABS_AF_API_TYPES -#include // For bool -#include // For various uint*_t types -#include // For NULL. +#include // For bool +#include // For NULL. +#include // For various uint*_t types #include "gen/enums.h" #include "types_stub.h" // For various types. @@ -105,7 +107,7 @@ typedef void (*EmberAfGenericClusterFunction)(void); * @brief An invalid profile ID * This is a reserved profileId. */ - #define EMBER_AF_INVALID_PROFILE_ID 0xFFFF +#define EMBER_AF_INVALID_PROFILE_ID 0xFFFF /** * @brief Type for default values. @@ -114,17 +116,18 @@ typedef void (*EmberAfGenericClusterFunction)(void); * or a pointer to the value itself, if attribute type is longer than * 2 bytes. */ -typedef union { - /** - * Points to data if size is more than 2 bytes. - * If size is more than 2 bytes, and this value is NULL, - * then the default value is all zeroes. - */ - uint8_t *ptrToDefaultValue; - /** - * Actual default value if the attribute size is 2 bytes or less. - */ - uint16_t defaultValue; +typedef union +{ + /** + * Points to data if size is more than 2 bytes. + * If size is more than 2 bytes, and this value is NULL, + * then the default value is all zeroes. + */ + uint8_t * ptrToDefaultValue; + /** + * Actual default value if the attribute size is 2 bytes or less. + */ + uint16_t defaultValue; } EmberAfDefaultAttributeValue; /** @@ -133,40 +136,42 @@ typedef union { * This struct is required if the attribute mask specifies that this * attribute has a known min and max values. */ -typedef struct { - /** - * Default value of the attribute. - */ - EmberAfDefaultAttributeValue defaultValue; - /** - * Minimum allowed value - */ - EmberAfDefaultAttributeValue minValue; - /** - * Maximum allowed value. - */ - EmberAfDefaultAttributeValue maxValue; +typedef struct +{ + /** + * Default value of the attribute. + */ + EmberAfDefaultAttributeValue defaultValue; + /** + * Minimum allowed value + */ + EmberAfDefaultAttributeValue minValue; + /** + * Maximum allowed value. + */ + EmberAfDefaultAttributeValue maxValue; } EmberAfAttributeMinMaxValue; /** * @brief Union describing the attribute default/min/max values. */ -typedef union { - /** - * Points to data if size is more than 2 bytes. - * If size is more than 2 bytes, and this value is NULL, - * then the default value is all zeroes. - */ - uint8_t *ptrToDefaultValue; - /** - * Actual default value if the attribute size is 2 bytes or less. - */ - uint16_t defaultValue; - /** - * Points to the min max attribute value structure, if min/max is - * supported for this attribute. - */ - EmberAfAttributeMinMaxValue *ptrToMinMaxValue; +typedef union +{ + /** + * Points to data if size is more than 2 bytes. + * If size is more than 2 bytes, and this value is NULL, + * then the default value is all zeroes. + */ + uint8_t * ptrToDefaultValue; + /** + * Actual default value if the attribute size is 2 bytes or less. + */ + uint16_t defaultValue; + /** + * Points to the min max attribute value structure, if min/max is + * supported for this attribute. + */ + EmberAfAttributeMinMaxValue * ptrToMinMaxValue; } EmberAfDefaultOrMinMaxAttributeValue; /** @@ -174,64 +179,66 @@ typedef union { * * There is only one of these per attribute across all endpoints. */ -typedef struct { - /** - * Attribute ID, according to ZCL specs. - */ - EmberAfAttributeId attributeId; - /** - * Attribute type, according to ZCL specs. - */ - EmberAfAttributeType attributeType; - /** - * Size of this attribute in bytes. - */ - uint8_t size; - /** - * Attribute mask, tagging attribute with specific - * functionality. See ATTRIBUTE_MASK_ macros defined - * in att-storage.h. - */ - EmberAfAttributeMask mask; - /** - * Pointer to the default value union. Actual value stored - * depends on the mask. - */ - EmberAfDefaultOrMinMaxAttributeValue defaultValue; +typedef struct +{ + /** + * Attribute ID, according to ZCL specs. + */ + EmberAfAttributeId attributeId; + /** + * Attribute type, according to ZCL specs. + */ + EmberAfAttributeType attributeType; + /** + * Size of this attribute in bytes. + */ + uint8_t size; + /** + * Attribute mask, tagging attribute with specific + * functionality. See ATTRIBUTE_MASK_ macros defined + * in att-storage.h. + */ + EmberAfAttributeMask mask; + /** + * Pointer to the default value union. Actual value stored + * depends on the mask. + */ + EmberAfDefaultOrMinMaxAttributeValue defaultValue; } EmberAfAttributeMetadata; /** * @brief Struct describing cluster */ -typedef struct { - /** - * ID of cluster according to ZCL spec - */ - EmberAfClusterId clusterId; - /** - * Pointer to attribute metadata array for this cluster. - */ - EmberAfAttributeMetadata *attributes; - /** - * Total number of attributes - */ - uint16_t attributeCount; - /** - * Total size of non-external, non-singleton attribute for this cluster. - */ - uint16_t clusterSize; - /** - * Mask with additional functionality for cluster. See CLUSTER_MASK - * macros. - */ - EmberAfClusterMask mask; - - /** - * An array into the cluster functions. The length of the array - * is determined by the function bits in mask. This may be null - * if this cluster has no functions. - */ - const EmberAfGenericClusterFunction *functions; +typedef struct +{ + /** + * ID of cluster according to ZCL spec + */ + EmberAfClusterId clusterId; + /** + * Pointer to attribute metadata array for this cluster. + */ + EmberAfAttributeMetadata * attributes; + /** + * Total number of attributes + */ + uint16_t attributeCount; + /** + * Total size of non-external, non-singleton attribute for this cluster. + */ + uint16_t clusterSize; + /** + * Mask with additional functionality for cluster. See CLUSTER_MASK + * macros. + */ + EmberAfClusterMask mask; + + /** + * An array into the cluster functions. The length of the array + * is determined by the function bits in mask. This may be null + * if this cluster has no functions. + */ + const EmberAfGenericClusterFunction * functions; } EmberAfCluster; /** @@ -239,53 +246,55 @@ typedef struct { * in this search record constitute the "primary key" used to identify a unique * attribute value in attribute storage. */ -typedef struct { - /** - * Endpoint that the attribute is located on - */ - uint8_t endpoint; - - /** - * Cluster that the attribute is located on. If the cluster - * id is inside the manufacturer specific range, 0xfc00 - 0xffff, - * The manufacturer code should also be set to the code associated - * with the manufacturer specific cluster. - */ - EmberAfClusterId clusterId; - - /** - * Cluster mask for the cluster, used to determine if it is - * the server or client version of the cluster. See CLUSTER_MASK_ - * macros defined in att-storage.h - */ - EmberAfClusterMask clusterMask; - - /** - * The two byte identifier for the attribute. If the cluster id is - * inside the manufacturer specific range 0xfc00 - 0xffff, or the manufacturer - * code is NOT 0, the attribute is assumed to be manufacturer specific. - */ - EmberAfAttributeId attributeId; - - /** - * Manufacturer Code associated with the cluster and or attribute. - * If the cluster id is inside the manufacturer specific - * range, this value should indicate the manufacturer code for the - * manufacturer specific cluster. Otherwise if this value is non zero, - * and the cluster id is a standard ZCL cluster, - * it is assumed that the attribute being sought is a manufacturer specific - * extension to the standard ZCL cluster indicated by the cluster id. - */ - uint16_t manufacturerCode; +typedef struct +{ + /** + * Endpoint that the attribute is located on + */ + uint8_t endpoint; + + /** + * Cluster that the attribute is located on. If the cluster + * id is inside the manufacturer specific range, 0xfc00 - 0xffff, + * The manufacturer code should also be set to the code associated + * with the manufacturer specific cluster. + */ + EmberAfClusterId clusterId; + + /** + * Cluster mask for the cluster, used to determine if it is + * the server or client version of the cluster. See CLUSTER_MASK_ + * macros defined in att-storage.h + */ + EmberAfClusterMask clusterMask; + + /** + * The two byte identifier for the attribute. If the cluster id is + * inside the manufacturer specific range 0xfc00 - 0xffff, or the manufacturer + * code is NOT 0, the attribute is assumed to be manufacturer specific. + */ + EmberAfAttributeId attributeId; + + /** + * Manufacturer Code associated with the cluster and or attribute. + * If the cluster id is inside the manufacturer specific + * range, this value should indicate the manufacturer code for the + * manufacturer specific cluster. Otherwise if this value is non zero, + * and the cluster id is a standard ZCL cluster, + * it is assumed that the attribute being sought is a manufacturer specific + * extension to the standard ZCL cluster indicated by the cluster id. + */ + uint16_t manufacturerCode; } EmberAfAttributeSearchRecord; /** * A struct used to construct a table of manufacturer codes for * manufacturer specific attributes and clusters. */ -typedef struct { - uint16_t index; - uint16_t manufacturerCode; +typedef struct +{ + uint16_t index; + uint16_t manufacturerCode; } EmberAfManufacturerCodeEntry; /** @@ -303,68 +312,69 @@ typedef uint32_t EmberAfDifferenceType; * passed to both emberIncomingMessageHandler on the SOC and * ezspIncomingMessageHandler on the host. */ -typedef struct { - /** - * The type of the incoming message - */ - EmberIncomingMessageType type; - /** - * APS frame for the incoming message - */ - EmberApsFrame* apsFrame; - /** - * The message copied into a flat buffer - */ - uint8_t* message; - /** - * Length of the incoming message - */ - uint16_t msgLen; - /** - * Two byte node id of the sending node. - */ - uint16_t source; - /** - * Link quality from the node that last relayed - * the message. - */ - uint8_t lastHopLqi; - /** - * The energy level (in units of dBm) observed during the reception. - */ - int8_t lastHopRssi; - /** - * The index of a binding that matches the message - * or 0xFF if there is no matching binding. - */ - uint8_t bindingTableIndex; - /** - * The index of the entry in the address table - * that matches the sender of the message or 0xFF - * if there is no matching entry. - */ - uint8_t addressTableIndex; - /** - * The index of the network on which this message was received. - */ - uint8_t networkIndex; +typedef struct +{ + /** + * The type of the incoming message + */ + EmberIncomingMessageType type; + /** + * APS frame for the incoming message + */ + EmberApsFrame * apsFrame; + /** + * The message copied into a flat buffer + */ + uint8_t * message; + /** + * Length of the incoming message + */ + uint16_t msgLen; + /** + * Two byte node id of the sending node. + */ + uint16_t source; + /** + * Link quality from the node that last relayed + * the message. + */ + uint8_t lastHopLqi; + /** + * The energy level (in units of dBm) observed during the reception. + */ + int8_t lastHopRssi; + /** + * The index of a binding that matches the message + * or 0xFF if there is no matching binding. + */ + uint8_t bindingTableIndex; + /** + * The index of the entry in the address table + * that matches the sender of the message or 0xFF + * if there is no matching entry. + */ + uint8_t addressTableIndex; + /** + * The index of the network on which this message was received. + */ + uint8_t networkIndex; } EmberAfIncomingMessage; /** * @brief Interpan Message type: unicast, broadcast, or multicast. */ typedef uint8_t EmberAfInterpanMessageType; -#define EMBER_AF_INTER_PAN_UNICAST 0x00 +#define EMBER_AF_INTER_PAN_UNICAST 0x00 #define EMBER_AF_INTER_PAN_BROADCAST 0x08 #define EMBER_AF_INTER_PAN_MULTICAST 0x0C // Legacy names -#define INTER_PAN_UNICAST EMBER_AF_INTER_PAN_UNICAST +#define INTER_PAN_UNICAST EMBER_AF_INTER_PAN_UNICAST #define INTER_PAN_BROADCAST EMBER_AF_INTER_PAN_BROADCAST #define INTER_PAN_MULTICAST EMBER_AF_INTER_PAN_MULTICAST -#define EMBER_AF_INTERPAN_OPTION_NONE 0x0000 -#define EMBER_AF_INTERPAN_OPTION_APS_ENCRYPT 0x0001 +#define EMBER_AF_INTERPAN_OPTION_NONE 0x0000 +#define EMBER_AF_INTERPAN_OPTION_APS_ENCRYPT 0x0001 #define EMBER_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS 0x0002 /** @@ -376,29 +386,30 @@ typedef uint16_t EmberAfInterpanOptions; * @brief Interpan header used for sending and receiving interpan * messages. */ -typedef struct { - EmberAfInterpanMessageType messageType; - - /** - * MAC addressing - * For outgoing messages this is the destination. For incoming messages - * it is the source, which always has a long address. - */ - EmberEUI64 longAddress; - EmberNodeId shortAddress; - EmberPanId panId; - - /** - * APS data - */ - EmberAfProfileId profileId; - EmberAfClusterId clusterId; - /** - * The groupId is only used for - * EMBER_AF_INTERPAN_MULTICAST - */ - EmberMulticastId groupId; - EmberAfInterpanOptions options; +typedef struct +{ + EmberAfInterpanMessageType messageType; + + /** + * MAC addressing + * For outgoing messages this is the destination. For incoming messages + * it is the source, which always has a long address. + */ + EmberEUI64 longAddress; + EmberNodeId shortAddress; + EmberPanId panId; + + /** + * APS data + */ + EmberAfProfileId profileId; + EmberAfClusterId clusterId; + /** + * The groupId is only used for + * EMBER_AF_INTERPAN_MULTICAST + */ + EmberMulticastId groupId; + EmberAfInterpanOptions options; } EmberAfInterpanHeader; // Legacy Name @@ -411,19 +422,20 @@ typedef uint8_t EmberAfAllowedInterpanOptions; #define EMBER_AF_INTERPAN_DIRECTION_CLIENT_TO_SERVER 0x01 #define EMBER_AF_INTERPAN_DIRECTION_SERVER_TO_CLIENT 0x02 -#define EMBER_AF_INTERPAN_DIRECTION_BOTH 0x03 -#define EMBER_AF_INTERPAN_GLOBAL_COMMAND 0x04 -#define EMBER_AF_INTERPAN_MANUFACTURER_SPECIFIC 0x08 +#define EMBER_AF_INTERPAN_DIRECTION_BOTH 0x03 +#define EMBER_AF_INTERPAN_GLOBAL_COMMAND 0x04 +#define EMBER_AF_INTERPAN_MANUFACTURER_SPECIFIC 0x08 /** * @brief This structure is used define an interpan message that * will be accepted by the interpan filters. */ -typedef struct { - EmberAfProfileId profileId; - EmberAfClusterId clusterId; - uint8_t commandId; - EmberAfAllowedInterpanOptions options; +typedef struct +{ + EmberAfProfileId profileId; + EmberAfClusterId clusterId; + uint8_t commandId; + EmberAfAllowedInterpanOptions options; } EmberAfAllowedInterPanMessage; /** @@ -434,59 +446,61 @@ typedef struct { * and pass a pointer to that location around during * command processing */ -typedef struct { - /** - * APS frame for the incoming message - */ - EmberApsFrame *apsFrame; - EmberIncomingMessageType type; - EmberNodeId source; - uint8_t *buffer; - uint16_t bufLen; - bool clusterSpecific; - bool mfgSpecific; - uint16_t mfgCode; - uint8_t seqNum; - uint8_t commandId; - uint8_t payloadStartIndex; - uint8_t direction; - EmberAfInterpanHeader *interPanHeader; - uint8_t networkIndex; +typedef struct +{ + /** + * APS frame for the incoming message + */ + EmberApsFrame * apsFrame; + EmberIncomingMessageType type; + EmberNodeId source; + uint8_t * buffer; + uint16_t bufLen; + bool clusterSpecific; + bool mfgSpecific; + uint16_t mfgCode; + uint8_t seqNum; + uint8_t commandId; + uint8_t payloadStartIndex; + uint8_t direction; + EmberAfInterpanHeader * interPanHeader; + uint8_t networkIndex; } EmberAfClusterCommand; /** * @brief Endpoint type struct describes clusters that are on the endpoint. */ -typedef struct { - /** - * Pointer to the cluster structs, describing clusters on this - * endpoint type. - */ - EmberAfCluster *cluster; - /** - * Number of clusters in this endpoint type. - */ - uint8_t clusterCount; - /** - * Size of all non-external, non-singlet attribute in this endpoint type. - */ - uint16_t endpointSize; +typedef struct +{ + /** + * Pointer to the cluster structs, describing clusters on this + * endpoint type. + */ + EmberAfCluster * cluster; + /** + * Number of clusters in this endpoint type. + */ + uint8_t clusterCount; + /** + * Size of all non-external, non-singlet attribute in this endpoint type. + */ + uint16_t endpointSize; } EmberAfEndpointType; #ifdef EZSP_HOST typedef EzspDecisionId EmberAfTcLinkKeyRequestPolicy; typedef EzspDecisionId EmberAfAppLinkKeyRequestPolicy; - #define EMBER_AF_ALLOW_TC_KEY_REQUESTS EZSP_ALLOW_TC_KEY_REQUESTS_AND_SEND_CURRENT_KEY - #define EMBER_AF_DENY_TC_KEY_REQUESTS EZSP_DENY_TC_KEY_REQUESTS - #define EMBER_AF_ALLOW_APP_KEY_REQUESTS EZSP_ALLOW_APP_KEY_REQUESTS - #define EMBER_AF_DENY_APP_KEY_REQUESTS EZSP_DENY_APP_KEY_REQUESTS +#define EMBER_AF_ALLOW_TC_KEY_REQUESTS EZSP_ALLOW_TC_KEY_REQUESTS_AND_SEND_CURRENT_KEY +#define EMBER_AF_DENY_TC_KEY_REQUESTS EZSP_DENY_TC_KEY_REQUESTS +#define EMBER_AF_ALLOW_APP_KEY_REQUESTS EZSP_ALLOW_APP_KEY_REQUESTS +#define EMBER_AF_DENY_APP_KEY_REQUESTS EZSP_DENY_APP_KEY_REQUESTS #else typedef EmberTcLinkKeyRequestPolicy EmberAfTcLinkKeyRequestPolicy; typedef EmberAppLinkKeyRequestPolicy EmberAfAppLinkKeyRequestPolicy; - #define EMBER_AF_ALLOW_TC_KEY_REQUESTS EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY - #define EMBER_AF_DENY_TC_KEY_REQUESTS EMBER_DENY_TC_LINK_KEY_REQUESTS - #define EMBER_AF_ALLOW_APP_KEY_REQUESTS EMBER_ALLOW_APP_LINK_KEY_REQUEST - #define EMBER_AF_DENY_APP_KEY_REQUESTS EMBER_DENY_APP_LINK_KEY_REQUESTS +#define EMBER_AF_ALLOW_TC_KEY_REQUESTS EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY +#define EMBER_AF_DENY_TC_KEY_REQUESTS EMBER_DENY_TC_LINK_KEY_REQUESTS +#define EMBER_AF_ALLOW_APP_KEY_REQUESTS EMBER_ALLOW_APP_LINK_KEY_REQUEST +#define EMBER_AF_DENY_APP_KEY_REQUESTS EMBER_DENY_APP_LINK_KEY_REQUESTS #endif #ifdef DOXYGEN_SHOULD_SKIP_THIS @@ -496,30 +510,32 @@ typedef uint8_t EmberAfSecurityProfile; enum #endif { - EMBER_AF_SECURITY_PROFILE_NONE = 0x00, - EMBER_AF_SECURITY_PROFILE_HA = 0x01, - EMBER_AF_SECURITY_PROFILE_HA12 = 0x02, - EMBER_AF_SECURITY_PROFILE_SE_TEST = 0x03, - EMBER_AF_SECURITY_PROFILE_SE_FULL = 0x04, - EMBER_AF_SECURITY_PROFILE_Z3 = 0x05, - EMBER_AF_SECURITY_PROFILE_CUSTOM = 0xFF, + EMBER_AF_SECURITY_PROFILE_NONE = 0x00, + EMBER_AF_SECURITY_PROFILE_HA = 0x01, + EMBER_AF_SECURITY_PROFILE_HA12 = 0x02, + EMBER_AF_SECURITY_PROFILE_SE_TEST = 0x03, + EMBER_AF_SECURITY_PROFILE_SE_FULL = 0x04, + EMBER_AF_SECURITY_PROFILE_Z3 = 0x05, + EMBER_AF_SECURITY_PROFILE_CUSTOM = 0xFF, }; -typedef struct { - EmberAfSecurityProfile securityProfile; - uint16_t tcBitmask; - EmberExtendedSecurityBitmask tcExtendedBitmask; - uint16_t nodeBitmask; - EmberExtendedSecurityBitmask nodeExtendedBitmask; - EmberAfTcLinkKeyRequestPolicy tcLinkKeyRequestPolicy; - EmberAfAppLinkKeyRequestPolicy appLinkKeyRequestPolicy; - EmberKeyData preconfiguredKey; +typedef struct +{ + EmberAfSecurityProfile securityProfile; + uint16_t tcBitmask; + EmberExtendedSecurityBitmask tcExtendedBitmask; + uint16_t nodeBitmask; + EmberExtendedSecurityBitmask nodeExtendedBitmask; + EmberAfTcLinkKeyRequestPolicy tcLinkKeyRequestPolicy; + EmberAfAppLinkKeyRequestPolicy appLinkKeyRequestPolicy; + EmberKeyData preconfiguredKey; } EmberAfSecurityProfileData; #ifndef DOXYGEN_SHOULD_SKIP_THIS -typedef struct { - EmberNodeType nodeType; - EmberAfSecurityProfile securityProfile; +typedef struct +{ + EmberNodeType nodeType; + EmberAfSecurityProfile securityProfile; } EmAfZigbeeProNetwork; #endif @@ -530,43 +546,43 @@ enum EmberAfEndpointBitmask; typedef uint8_t EmberAfEndpointBitmask; enum #endif -{ - EMBER_AF_ENDPOINT_DISABLED = 0x00, +{ EMBER_AF_ENDPOINT_DISABLED = 0x00, EMBER_AF_ENDPOINT_ENABLED = 0x01, }; /** * @brief Struct that maps actual endpoint type, onto a specific endpoint. */ -typedef struct { - /** - * Actual zigbee endpoint number. - */ - uint8_t endpoint; - /** - * Profile ID of the device on this endpoint. - */ - EmberAfProfileId profileId; - /** - * Device ID of the device on this endpoint. - */ - uint16_t deviceId; - /** - * Version of the device. - */ - uint8_t deviceVersion; - /** - * Endpoint type for this endpoint. - */ - EmberAfEndpointType *endpointType; - /** - * Network index for this endpoint. - */ - uint8_t networkIndex; - /** - * Meta-data about the endpoint - */ - EmberAfEndpointBitmask bitmask; +typedef struct +{ + /** + * Actual zigbee endpoint number. + */ + uint8_t endpoint; + /** + * Profile ID of the device on this endpoint. + */ + EmberAfProfileId profileId; + /** + * Device ID of the device on this endpoint. + */ + uint16_t deviceId; + /** + * Version of the device. + */ + uint8_t deviceVersion; + /** + * Endpoint type for this endpoint. + */ + EmberAfEndpointType * endpointType; + /** + * Network index for this endpoint. + */ + uint8_t networkIndex; + /** + * Meta-data about the endpoint + */ + EmberAfEndpointBitmask bitmask; } EmberAfDefinedEndpoint; // Cluster specific types @@ -582,7 +598,7 @@ typedef uint16_t EmberAfPluginEsiManagementBitmask; #elif (EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 32) typedef uint32_t EmberAfPluginEsiManagementBitmask; #else - #error "EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE cannot exceed 32" +#error "EMBER_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE cannot exceed 32" #endif /** @@ -591,39 +607,40 @@ typedef uint32_t EmberAfPluginEsiManagementBitmask; * This is used in the load control event callback and * within the demand response load control cluster code. */ -typedef struct { - uint32_t eventId; +typedef struct +{ + uint32_t eventId; #ifdef EMBER_AF_PLUGIN_DRLC_SERVER - EmberEUI64 source; - uint8_t sourceEndpoint; -#endif //EMBER_AF_PLUGIN_DRLC_SERVER + EmberEUI64 source; + uint8_t sourceEndpoint; +#endif // EMBER_AF_PLUGIN_DRLC_SERVER #ifdef EMBER_AF_PLUGIN_DRLC - EmberAfPluginEsiManagementBitmask esiBitmask; -#endif //EMBER_AF_PLUGIN_DRLC - - uint8_t destinationEndpoint; - uint16_t deviceClass; - uint8_t utilityEnrollmentGroup; - /** - * Start time in seconds - */ - uint32_t startTime; - /** - * Duration in minutes - */ - uint16_t duration; - uint8_t criticalityLevel; - uint8_t coolingTempOffset; - uint8_t heatingTempOffset; - int16_t coolingTempSetPoint; - int16_t heatingTempSetPoint; - int8_t avgLoadPercentage; - uint8_t dutyCycle; - uint8_t eventControl; - uint32_t startRand; - uint32_t durationRand; - uint8_t optionControl; + EmberAfPluginEsiManagementBitmask esiBitmask; +#endif // EMBER_AF_PLUGIN_DRLC + + uint8_t destinationEndpoint; + uint16_t deviceClass; + uint8_t utilityEnrollmentGroup; + /** + * Start time in seconds + */ + uint32_t startTime; + /** + * Duration in minutes + */ + uint16_t duration; + uint8_t criticalityLevel; + uint8_t coolingTempOffset; + uint8_t heatingTempOffset; + int16_t coolingTempSetPoint; + int16_t heatingTempSetPoint; + int8_t avgLoadPercentage; + uint8_t dutyCycle; + uint8_t eventControl; + uint32_t startRand; + uint32_t durationRand; + uint8_t optionControl; } EmberAfLoadControlEvent; /** @@ -632,14 +649,15 @@ typedef struct { * as soon as a response is received. Broadcast discoveries * wait a period of time for multiple responses to be received. */ -typedef enum { - EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE = 0x00, - EMBER_AF_BROADCAST_SERVICE_DISCOVERY_RESPONSE_RECEIVED = 0x01, - EMBER_AF_UNICAST_SERVICE_DISCOVERY_TIMEOUT = 0x02, - EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x03, - EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x04, - EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x05, - EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x06, +typedef enum +{ + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE = 0x00, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_RESPONSE_RECEIVED = 0x01, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_TIMEOUT = 0x02, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x03, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x04, + EMBER_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x05, + EMBER_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x06, } EmberAfServiceDiscoveryStatus; #define EM_AF_DISCOVERY_RESPONSE_MASK (0x05) @@ -648,43 +666,44 @@ typedef enum { * @brief A simple way to determine if the service discovery callback * has a response. */ -#define emberAfHaveDiscoveryResponseStatus(status) ((status) & EM_AF_DISCOVERY_RESPONSE_MASK) +#define emberAfHaveDiscoveryResponseStatus(status) ((status) &EM_AF_DISCOVERY_RESPONSE_MASK) /** * @brief A structure containing general information about the service discovery. */ -typedef struct { - /** - * The status indicates both the type of request (broadcast or unicast) - * and whether a response has been received. - */ - EmberAfServiceDiscoveryStatus status; - - /** - * This indicates what ZDO request cluster was associated with the request. - * It is helpful for a callback that may be used for multiple ZDO request types - * to determine the type of data returned. This will be based on the - * ZDO cluster values defined in ember-types.h. - */ - uint16_t zdoRequestClusterId; - - /** - * This is the address of the device that matched the request, which may - * be different than the device that *actually* is responding. This occurs - * when parents respond on behalf of their children. - */ - EmberNodeId matchAddress; - - /** - * Only if the status code indicates a response will this data be non-NULL. - * When there is data, the type is according to the ZDO cluster ID sent out. - * For NETWORK_ADDRESS_REQUEST or IEEE_ADDRESS_REQUEST, the long ID will - * be contained in the responseData, so it will be a value of type ::EmberEUI64. - * The short ID will be in the matchAddress parameter field. - * For the MATCH_DESCRIPTORS_REQUEST the responseData will point - * to an ::EmberAfEndpointList structure. - */ - const void* responseData; +typedef struct +{ + /** + * The status indicates both the type of request (broadcast or unicast) + * and whether a response has been received. + */ + EmberAfServiceDiscoveryStatus status; + + /** + * This indicates what ZDO request cluster was associated with the request. + * It is helpful for a callback that may be used for multiple ZDO request types + * to determine the type of data returned. This will be based on the + * ZDO cluster values defined in ember-types.h. + */ + uint16_t zdoRequestClusterId; + + /** + * This is the address of the device that matched the request, which may + * be different than the device that *actually* is responding. This occurs + * when parents respond on behalf of their children. + */ + EmberNodeId matchAddress; + + /** + * Only if the status code indicates a response will this data be non-NULL. + * When there is data, the type is according to the ZDO cluster ID sent out. + * For NETWORK_ADDRESS_REQUEST or IEEE_ADDRESS_REQUEST, the long ID will + * be contained in the responseData, so it will be a value of type ::EmberEUI64. + * The short ID will be in the matchAddress parameter field. + * For the MATCH_DESCRIPTORS_REQUEST the responseData will point + * to an ::EmberAfEndpointList structure. + */ + const void * responseData; } EmberAfServiceDiscoveryResult; /** @@ -692,23 +711,25 @@ typedef struct { * This will be returned for a match descriptor request and a * active endpoint request. */ -typedef struct { - uint8_t count; - const uint8_t* list; +typedef struct +{ + uint8_t count; + const uint8_t * list; } EmberAfEndpointList; /** * @brief A list of clusters received during a service discovery attempt. * This will be returned for a simple descriptor request. */ -typedef struct { - uint8_t inClusterCount; - const uint16_t* inClusterList; - uint8_t outClusterCount; - const uint16_t* outClusterList; - EmberAfProfileId profileId; - uint16_t deviceId; - uint8_t endpoint; +typedef struct +{ + uint8_t inClusterCount; + const uint16_t * inClusterList; + uint8_t outClusterCount; + const uint16_t * outClusterList; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; } EmberAfClusterList; /** @@ -722,7 +743,7 @@ typedef struct { * After a couple seconds the callback will then be fired with * ::EMBER_AF_SERVICE_DISCOVERY_COMPLETE as the result. */ -typedef void (EmberAfServiceDiscoveryCallback)(const EmberAfServiceDiscoveryResult* result); +typedef void(EmberAfServiceDiscoveryCallback)(const EmberAfServiceDiscoveryResult * result); /** * @brief This defines a callback where a code element or cluster can be @@ -730,7 +751,7 @@ typedef void (EmberAfServiceDiscoveryCallback)(const EmberAfServiceDiscoveryResu * exchange. The callback will be triggered with success equal to true if the * exchange completed successfully. */ -typedef void (EmberAfPartnerLinkKeyExchangeCallback)(bool success); +typedef void(EmberAfPartnerLinkKeyExchangeCallback)(bool success); /** * @brief This is an enum used to control how the device will poll for a given @@ -741,9 +762,10 @@ typedef void (EmberAfPartnerLinkKeyExchangeCallback)(bool success); * with EMBER_AF_LONG_POLL and the other with EMBER_AF_SHORT_POLL, then the * processor will short poll until the second event is deactivated. */ -typedef enum { - EMBER_AF_LONG_POLL, - EMBER_AF_SHORT_POLL, +typedef enum +{ + EMBER_AF_LONG_POLL, + EMBER_AF_SHORT_POLL, } EmberAfEventPollControl; /** @@ -759,13 +781,14 @@ typedef enum { * will only be allowed to nap until the second event * is deactivated. */ -typedef enum { - EMBER_AF_OK_TO_SLEEP, - /** @deprecated. */ - EMBER_AF_OK_TO_HIBERNATE = EMBER_AF_OK_TO_SLEEP, - /** @deprecated. */ - EMBER_AF_OK_TO_NAP, - EMBER_AF_STAY_AWAKE, +typedef enum +{ + EMBER_AF_OK_TO_SLEEP, + /** @deprecated. */ + EMBER_AF_OK_TO_HIBERNATE = EMBER_AF_OK_TO_SLEEP, + /** @deprecated. */ + EMBER_AF_OK_TO_NAP, + EMBER_AF_STAY_AWAKE, } EmberAfEventSleepControl; /** @@ -801,18 +824,18 @@ typedef uint32_t EmberAfApplicationTask; enum #endif { - // we may be able to remove these top two since they are - // handled by the stack on the SOC. - EMBER_AF_WAITING_FOR_DATA_ACK = 0x00000001, //not needed? - EMBER_AF_LAST_POLL_GOT_DATA = 0x00000002, //not needed? - EMBER_AF_WAITING_FOR_SERVICE_DISCOVERY = 0x00000004, - EMBER_AF_WAITING_FOR_ZDO_RESPONSE = 0x00000008, - EMBER_AF_WAITING_FOR_ZCL_RESPONSE = 0x00000010, - EMBER_AF_WAITING_FOR_REGISTRATION = 0x00000020, - EMBER_AF_WAITING_FOR_PARTNER_LINK_KEY_EXCHANGE = 0x00000040, - EMBER_AF_FORCE_SHORT_POLL = 0x00000080, - EMBER_AF_FRAGMENTATION_IN_PROGRESS = 0x00000100, - EMBER_AF_FORCE_SHORT_POLL_FOR_PARENT_CONNECTIVITY = 0x00000200, + // we may be able to remove these top two since they are + // handled by the stack on the SOC. + EMBER_AF_WAITING_FOR_DATA_ACK = 0x00000001, // not needed? + EMBER_AF_LAST_POLL_GOT_DATA = 0x00000002, // not needed? + EMBER_AF_WAITING_FOR_SERVICE_DISCOVERY = 0x00000004, + EMBER_AF_WAITING_FOR_ZDO_RESPONSE = 0x00000008, + EMBER_AF_WAITING_FOR_ZCL_RESPONSE = 0x00000010, + EMBER_AF_WAITING_FOR_REGISTRATION = 0x00000020, + EMBER_AF_WAITING_FOR_PARTNER_LINK_KEY_EXCHANGE = 0x00000040, + EMBER_AF_FORCE_SHORT_POLL = 0x00000080, + EMBER_AF_FRAGMENTATION_IN_PROGRESS = 0x00000100, + EMBER_AF_FORCE_SHORT_POLL_FOR_PARENT_CONNECTIVITY = 0x00000200, }; /** @@ -823,34 +846,35 @@ enum * context table which along with helper functions allows the cluster * code to schedule and deactivate its associated events. */ -typedef struct { - /** - * The endpoint of the associated cluster event. - */ - uint8_t endpoint; - /** - * The cluster id of the associated cluster event. - */ - EmberAfClusterId clusterId; - /** - * The server/client identity of the associated cluster event. - */ - bool isClient; - /** - * A poll control value used to control the network polling behavior while - * the event is active. - */ - EmberAfEventPollControl pollControl; - /** - * A sleep control value used to control the processor's sleep - * behavior while the event is active. - */ - EmberAfEventSleepControl sleepControl; - /** - * A pointer to the event control value which is stored in the event table - * and is used to actually schedule the event. - */ - EmberEventControl *eventControl; +typedef struct +{ + /** + * The endpoint of the associated cluster event. + */ + uint8_t endpoint; + /** + * The cluster id of the associated cluster event. + */ + EmberAfClusterId clusterId; + /** + * The server/client identity of the associated cluster event. + */ + bool isClient; + /** + * A poll control value used to control the network polling behavior while + * the event is active. + */ + EmberAfEventPollControl pollControl; + /** + * A sleep control value used to control the processor's sleep + * behavior while the event is active. + */ + EmberAfEventSleepControl sleepControl; + /** + * A pointer to the event control value which is stored in the event table + * and is used to actually schedule the event. + */ + EmberEventControl * eventControl; } EmberAfEventContext; /** @@ -882,15 +906,16 @@ typedef void (*EmberAfEndpointEventHandler)(uint8_t endpoint); * depending on the platform. If the endpoint field is * ::EMBER_AF_GROUP_TABLE_UNUSED_ENDPOINT_ID, the entry is unused. */ -typedef struct { - uint8_t endpoint; // 0x00 when not in use - uint16_t groupId; - uint8_t bindingIndex; +typedef struct +{ + uint8_t endpoint; // 0x00 when not in use + uint16_t groupId; + uint8_t bindingIndex; #ifdef EMBER_AF_PLUGIN_GROUPS_SERVER_NAME_SUPPORT - uint8_t name[ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; + uint8_t name[ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; #endif } EmberAfGroupTableEntry; -#endif //EMBER_AF_PLUGIN_GROUPS_SERVER +#endif // EMBER_AF_PLUGIN_GROUPS_SERVER /** * @brief Indicates the absence of a Scene table entry. @@ -918,58 +943,59 @@ typedef struct { * depending on a plugin setting. If endpoint field is * ::EMBER_AF_SCENE_TABLE_UNUSED_ENDPOINT_ID, the entry is unused. */ -typedef struct { - uint8_t endpoint; // 0x00 when this record is not in use - uint16_t groupId; // 0x0000 if not associated with a group - uint8_t sceneId; +typedef struct +{ + uint8_t endpoint; // 0x00 when this record is not in use + uint16_t groupId; // 0x0000 if not associated with a group + uint8_t sceneId; #ifdef EMBER_AF_PLUGIN_SCENES_NAME_SUPPORT - uint8_t name[ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; + uint8_t name[ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH + 1]; #endif - uint16_t transitionTime; // in seconds - uint8_t transitionTime100ms; // in tenths of a seconds + uint16_t transitionTime; // in seconds + uint8_t transitionTime100ms; // in tenths of a seconds #ifdef ZCL_USING_ON_OFF_CLUSTER_SERVER - bool hasOnOffValue; - bool onOffValue; + bool hasOnOffValue; + bool onOffValue; #endif #ifdef ZCL_USING_LEVEL_CONTROL_CLUSTER_SERVER - bool hasCurrentLevelValue; - uint8_t currentLevelValue; + bool hasCurrentLevelValue; + uint8_t currentLevelValue; #endif #ifdef ZCL_USING_THERMOSTAT_CLUSTER_SERVER - bool hasOccupiedCoolingSetpointValue; - int16_t occupiedCoolingSetpointValue; - bool hasOccupiedHeatingSetpointValue; - int16_t occupiedHeatingSetpointValue; - bool hasSystemModeValue; - uint8_t systemModeValue; + bool hasOccupiedCoolingSetpointValue; + int16_t occupiedCoolingSetpointValue; + bool hasOccupiedHeatingSetpointValue; + int16_t occupiedHeatingSetpointValue; + bool hasSystemModeValue; + uint8_t systemModeValue; #endif #ifdef ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER - bool hasCurrentXValue; - uint16_t currentXValue; - bool hasCurrentYValue; - uint16_t currentYValue; - bool hasEnhancedCurrentHueValue; - uint16_t enhancedCurrentHueValue; - bool hasCurrentSaturationValue; - uint8_t currentSaturationValue; - bool hasColorLoopActiveValue; - uint8_t colorLoopActiveValue; - bool hasColorLoopDirectionValue; - uint8_t colorLoopDirectionValue; - bool hasColorLoopTimeValue; - uint16_t colorLoopTimeValue; - bool hasColorTemperatureMiredsValue; - uint16_t colorTemperatureMiredsValue; -#endif //ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER + bool hasCurrentXValue; + uint16_t currentXValue; + bool hasCurrentYValue; + uint16_t currentYValue; + bool hasEnhancedCurrentHueValue; + uint16_t enhancedCurrentHueValue; + bool hasCurrentSaturationValue; + uint8_t currentSaturationValue; + bool hasColorLoopActiveValue; + uint8_t colorLoopActiveValue; + bool hasColorLoopDirectionValue; + uint8_t colorLoopDirectionValue; + bool hasColorLoopTimeValue; + uint16_t colorLoopTimeValue; + bool hasColorTemperatureMiredsValue; + uint16_t colorTemperatureMiredsValue; +#endif // ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER #ifdef ZCL_USING_DOOR_LOCK_CLUSTER_SERVER - bool hasLockStateValue; - uint8_t lockStateValue; + bool hasLockStateValue; + uint8_t lockStateValue; #endif #ifdef ZCL_USING_WINDOW_COVERING_CLUSTER_SERVER - bool hasCurrentPositionLiftPercentageValue; - uint8_t currentPositionLiftPercentageValue; - bool hasCurrentPositionTiltPercentageValue; - uint8_t currentPositionTiltPercentageValue; + bool hasCurrentPositionLiftPercentageValue; + uint8_t currentPositionLiftPercentageValue; + bool hasCurrentPositionTiltPercentageValue; + uint8_t currentPositionTiltPercentageValue; #endif } EmberAfSceneTableEntry; @@ -977,47 +1003,49 @@ typedef struct { // In order to be able to forward declare callbacks regardless of whether the plugin // is enabled, we need to define all data structures. In order to be able to define // the messaging client data struct, we need to declare this variable. - #define EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE 0 +#define EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE 0 #endif -typedef struct { - bool valid; - bool active; - EmberAfPluginEsiManagementBitmask esiBitmask; - uint8_t clientEndpoint; - uint32_t messageId; - uint8_t messageControl; - uint32_t startTime; - uint32_t endTime; - uint16_t durationInMinutes; - uint8_t message[EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE + 1]; +typedef struct +{ + bool valid; + bool active; + EmberAfPluginEsiManagementBitmask esiBitmask; + uint8_t clientEndpoint; + uint32_t messageId; + uint8_t messageControl; + uint32_t startTime; + uint32_t endTime; + uint16_t durationInMinutes; + uint8_t message[EMBER_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE + 1]; } EmberAfPluginMessagingClientMessage; #define ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH 11 -typedef struct { - bool valid; - bool active; - uint8_t clientEndpoint; - uint32_t providerId; - uint8_t rateLabel[ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH + 1]; - uint32_t issuerEventId; - uint32_t currentTime; - uint8_t unitOfMeasure; - uint16_t currency; - uint8_t priceTrailingDigitAndPriceTier; - uint8_t numberOfPriceTiersAndRegisterTier; - uint32_t startTime; - uint32_t endTime; - uint16_t durationInMinutes; - uint32_t price; - uint8_t priceRatio; - uint32_t generationPrice; - uint8_t generationPriceRatio; - uint32_t alternateCostDelivered; - uint8_t alternateCostUnit; - uint8_t alternateCostTrailingDigit; - uint8_t numberOfBlockThresholds; - uint8_t priceControl; +typedef struct +{ + bool valid; + bool active; + uint8_t clientEndpoint; + uint32_t providerId; + uint8_t rateLabel[ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH + 1]; + uint32_t issuerEventId; + uint32_t currentTime; + uint8_t unitOfMeasure; + uint16_t currency; + uint8_t priceTrailingDigitAndPriceTier; + uint8_t numberOfPriceTiersAndRegisterTier; + uint32_t startTime; + uint32_t endTime; + uint16_t durationInMinutes; + uint32_t price; + uint8_t priceRatio; + uint32_t generationPrice; + uint8_t generationPriceRatio; + uint32_t alternateCostDelivered; + uint8_t alternateCostUnit; + uint8_t alternateCostTrailingDigit; + uint8_t numberOfBlockThresholds; + uint8_t priceControl; } EmberAfPluginPriceClientPrice; /** @@ -1030,11 +1058,11 @@ typedef uint8_t EmberAfPluginPriceCppAuth; enum #endif { - EMBER_AF_PLUGIN_PRICE_CPP_AUTH_PENDING = 0, - EMBER_AF_PLUGIN_PRICE_CPP_AUTH_ACCEPTED = 1, - EMBER_AF_PLUGIN_PRICE_CPP_AUTH_REJECTED = 2, - EMBER_AF_PLUGIN_PRICE_CPP_AUTH_FORCED = 3, - EMBER_AF_PLUGIN_PRICE_CPP_AUTH_RESERVED = 4 + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_PENDING = 0, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_ACCEPTED = 1, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_REJECTED = 2, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_FORCED = 3, + EMBER_AF_PLUGIN_PRICE_CPP_AUTH_RESERVED = 4 }; /** @@ -1047,67 +1075,72 @@ enum * field is ::EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID, the entry is * unused. */ -typedef struct { - /** EMBER_ZCL_REPORTING_DIRECTION_REPORTED for reports sent from the local - * device or EMBER_ZCL_REPORTING_DIRECTION_RECEIVED for reports received - * from a remote device. - */ - EmberAfReportingDirection direction; - /** The local endpoint from which the attribute is reported or to which the - * report is received. If ::EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID, - * the entry is unused. - */ - uint8_t endpoint; - /** The cluster where the attribute is located. */ - EmberAfClusterId clusterId; - /** The id of the attribute being reported or received. */ - EmberAfAttributeId attributeId; - /** CLUSTER_MASK_SERVER for server-side attributes or CLUSTER_MASK_CLIENT for - * client-side attributes. - */ - uint8_t mask; - /** Manufacturer code associated with the cluster and/or attribute. If the - * cluster id is inside the manufacturer-specific range, this value - * indicates the manufacturer code for the cluster. Otherwise, if this - * value is non-zero and the cluster id is a standard ZCL cluster, it - * indicates the manufacturer code for attribute. - */ - uint16_t manufacturerCode; - union { - struct { - /** The minimum reporting interval, measured in seconds. */ - uint16_t minInterval; - /** The maximum reporting interval, measured in seconds. */ - uint16_t maxInterval; - /** The minimum change to the attribute that will result in a report - * being sent. - */ - uint32_t reportableChange; - } reported; - struct { - /** The node id of the source of the received reports. */ - EmberNodeId source; - /** The remote endpoint from which the attribute is reported. */ - uint8_t endpoint; - /** The maximum expected time between reports, measured in seconds. */ - uint16_t timeout; - } received; - } data; +typedef struct +{ + /** EMBER_ZCL_REPORTING_DIRECTION_REPORTED for reports sent from the local + * device or EMBER_ZCL_REPORTING_DIRECTION_RECEIVED for reports received + * from a remote device. + */ + EmberAfReportingDirection direction; + /** The local endpoint from which the attribute is reported or to which the + * report is received. If ::EMBER_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID, + * the entry is unused. + */ + uint8_t endpoint; + /** The cluster where the attribute is located. */ + EmberAfClusterId clusterId; + /** The id of the attribute being reported or received. */ + EmberAfAttributeId attributeId; + /** CLUSTER_MASK_SERVER for server-side attributes or CLUSTER_MASK_CLIENT for + * client-side attributes. + */ + uint8_t mask; + /** Manufacturer code associated with the cluster and/or attribute. If the + * cluster id is inside the manufacturer-specific range, this value + * indicates the manufacturer code for the cluster. Otherwise, if this + * value is non-zero and the cluster id is a standard ZCL cluster, it + * indicates the manufacturer code for attribute. + */ + uint16_t manufacturerCode; + union + { + struct + { + /** The minimum reporting interval, measured in seconds. */ + uint16_t minInterval; + /** The maximum reporting interval, measured in seconds. */ + uint16_t maxInterval; + /** The minimum change to the attribute that will result in a report + * being sent. + */ + uint32_t reportableChange; + } reported; + struct + { + /** The node id of the source of the received reports. */ + EmberNodeId source; + /** The remote endpoint from which the attribute is reported. */ + uint8_t endpoint; + /** The maximum expected time between reports, measured in seconds. */ + uint16_t timeout; + } received; + } data; } EmberAfPluginReportingEntry; -typedef enum { - EMBER_AF_PLUGIN_TUNNELING_CLIENT_SUCCESS = 0x00, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_BUSY = 0x01, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_NO_MORE_TUNNEL_IDS = 0x02, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_PROTOCOL_NOT_SUPPORTED = 0x03, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_FLOW_CONTROL_NOT_SUPPORTED = 0x04, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_REQUEST_FAILED = 0xF9, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_NOT_FOUND = 0xFA, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_ADDRESS_TABLE_FULL = 0xFB, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_REQUEST_FAILED = 0xFC, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_FAILED = 0xFD, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_FAILED = 0xFE, - EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_TIMEOUT = 0xFF, +typedef enum +{ + EMBER_AF_PLUGIN_TUNNELING_CLIENT_SUCCESS = 0x00, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_BUSY = 0x01, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_NO_MORE_TUNNEL_IDS = 0x02, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_PROTOCOL_NOT_SUPPORTED = 0x03, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_FLOW_CONTROL_NOT_SUPPORTED = 0x04, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_REQUEST_FAILED = 0xF9, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_NOT_FOUND = 0xFA, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_ADDRESS_TABLE_FULL = 0xFB, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_REQUEST_FAILED = 0xFC, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_FAILED = 0xFD, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_FAILED = 0xFE, + EMBER_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_TIMEOUT = 0xFF, } EmberAfPluginTunnelingClientStatus; #ifdef EMBER_AF_PLUGIN_ZLL_COMMISSIONING_COMMON @@ -1121,38 +1154,40 @@ typedef uint8_t EmberAfZllCommissioningStatus; enum #endif { - EMBER_AF_ZLL_ABORTED_BY_APPLICATION = 0x00, - EMBER_AF_ZLL_CHANNEL_CHANGE_FAILED = 0x01, - EMBER_AF_ZLL_JOINING_FAILED = 0x02, - EMBER_AF_ZLL_NO_NETWORKS_FOUND = 0x03, - EMBER_AF_ZLL_PREEMPTED_BY_STACK = 0x04, - EMBER_AF_ZLL_SENDING_START_JOIN_FAILED = 0x05, - EMBER_AF_ZLL_SENDING_DEVICE_INFORMATION_REQUEST_FAILED = 0x06, - EMBER_AF_ZLL_SENDING_IDENTIFY_REQUEST_FAILED = 0x07, - EMBER_AF_ZLL_SENDING_RESET_TO_FACTORY_NEW_REQUEST_FAILED = 0x08, - EMBER_AF_ZLL_NETWORK_FORMATION_FAILED = 0x09, - EMBER_AF_ZLL_NETWORK_UPDATE_OPERATION = 0x0A, + EMBER_AF_ZLL_ABORTED_BY_APPLICATION = 0x00, + EMBER_AF_ZLL_CHANNEL_CHANGE_FAILED = 0x01, + EMBER_AF_ZLL_JOINING_FAILED = 0x02, + EMBER_AF_ZLL_NO_NETWORKS_FOUND = 0x03, + EMBER_AF_ZLL_PREEMPTED_BY_STACK = 0x04, + EMBER_AF_ZLL_SENDING_START_JOIN_FAILED = 0x05, + EMBER_AF_ZLL_SENDING_DEVICE_INFORMATION_REQUEST_FAILED = 0x06, + EMBER_AF_ZLL_SENDING_IDENTIFY_REQUEST_FAILED = 0x07, + EMBER_AF_ZLL_SENDING_RESET_TO_FACTORY_NEW_REQUEST_FAILED = 0x08, + EMBER_AF_ZLL_NETWORK_FORMATION_FAILED = 0x09, + EMBER_AF_ZLL_NETWORK_UPDATE_OPERATION = 0x0A, }; /** * @brief A structure used to represent Group Information Records used by ZLL * Commissioning. */ -typedef struct { - EmberMulticastId groupId; - uint8_t groupType; +typedef struct +{ + EmberMulticastId groupId; + uint8_t groupType; } EmberAfPluginZllCommissioningGroupInformationRecord; /** * @brief A structure used to represent Endpoint Information Records used by * ZLL Commissioning. */ -typedef struct { - EmberNodeId networkAddress; - uint8_t endpointId; - uint16_t profileId; - uint16_t deviceId; - uint8_t version; +typedef struct +{ + EmberNodeId networkAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; } EmberAfPluginZllCommissioningEndpointInformationRecord; #endif @@ -1161,32 +1196,34 @@ typedef struct { * images. It is used by the OTA plugins when passing around information about * an upgrade file. */ -typedef struct { - uint16_t manufacturerId; - uint16_t imageTypeId; - uint32_t firmwareVersion; - - /** - * This is only used for device specific files. - * It will be set to all 0's when the image does not - * have an upgrade destination field in it. - * Little endian format. - */ - uint8_t deviceSpecificFileEui64[EUI64_SIZE]; +typedef struct +{ + uint16_t manufacturerId; + uint16_t imageTypeId; + uint32_t firmwareVersion; + + /** + * This is only used for device specific files. + * It will be set to all 0's when the image does not + * have an upgrade destination field in it. + * Little endian format. + */ + uint8_t deviceSpecificFileEui64[EUI64_SIZE]; } EmberAfOtaImageId; /** * @brief The list of options possible for the image block request/response. */ -enum { - EMBER_AF_IMAGE_BLOCK_REQUEST_OPTIONS_NONE = 0x00, - // Client supports Min Block Request field - EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_CLIENT = 0x01, - // Server supports Min Block Request field - EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_SERVER = 0x02, - // The Image Block Request is actually simulated in place of an actually - // received Image Page Request - EMBER_AF_IMAGE_BLOCK_REQUEST_SIMULATED_FROM_PAGE_REQUEST = 0x04 +enum +{ + EMBER_AF_IMAGE_BLOCK_REQUEST_OPTIONS_NONE = 0x00, + // Client supports Min Block Request field + EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_CLIENT = 0x01, + // Server supports Min Block Request field + EMBER_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_SERVER = 0x02, + // The Image Block Request is actually simulated in place of an actually + // received Image Page Request + EMBER_AF_IMAGE_BLOCK_REQUEST_SIMULATED_FROM_PAGE_REQUEST = 0x04 }; typedef uint8_t EmberAfImageBlockRequestOptions; @@ -1194,44 +1231,47 @@ typedef uint8_t EmberAfImageBlockRequestOptions; * @brief This is the data structure that is passed to the * emberAfImageBlockRequestCallback() to let the application decide what to do. */ -typedef struct { - const EmberAfOtaImageId* id; - uint32_t offset; - uint32_t waitTimeSecondsResponse; - EmberNodeId source; - EmberEUI64 sourceEui; // optionally present in messages - // The minBlockRequestPeriod can be treated as milliseconds or seconds on the - // client. The OTA server plugin has optional support to probe clients and - // treat this field with appropriate units (ms or sec) - uint16_t minBlockRequestPeriod; // optionally present in messages - uint8_t maxDataSize; - uint8_t clientEndpoint; - EmberAfImageBlockRequestOptions bitmask; +typedef struct +{ + const EmberAfOtaImageId * id; + uint32_t offset; + uint32_t waitTimeSecondsResponse; + EmberNodeId source; + EmberEUI64 sourceEui; // optionally present in messages + // The minBlockRequestPeriod can be treated as milliseconds or seconds on the + // client. The OTA server plugin has optional support to probe clients and + // treat this field with appropriate units (ms or sec) + uint16_t minBlockRequestPeriod; // optionally present in messages + uint8_t maxDataSize; + uint8_t clientEndpoint; + EmberAfImageBlockRequestOptions bitmask; } EmberAfImageBlockRequestCallbackStruct; /** * @brief This status contains the success or error code of an OTA storage * device operation. */ -typedef enum { - EMBER_AF_OTA_STORAGE_SUCCESS = 0, - EMBER_AF_OTA_STORAGE_ERROR = 1, - EMBER_AF_OTA_STORAGE_RETURN_DATA_TOO_LONG = 2, - EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND = 3, - EMBER_AF_OTA_STORAGE_OPERATION_IN_PROGRESS = 4, +typedef enum +{ + EMBER_AF_OTA_STORAGE_SUCCESS = 0, + EMBER_AF_OTA_STORAGE_ERROR = 1, + EMBER_AF_OTA_STORAGE_RETURN_DATA_TOO_LONG = 2, + EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND = 3, + EMBER_AF_OTA_STORAGE_OPERATION_IN_PROGRESS = 4, } EmberAfOtaStorageStatus; /** * @brief This status contains the success or error code of an OTA download * operation. */ -enum { - EMBER_AF_OTA_DOWNLOAD_AND_VERIFY_SUCCESS = 0, - EMBER_AF_OTA_DOWNLOAD_TIME_OUT = 1, - EMBER_AF_OTA_VERIFY_FAILED = 2, - EMBER_AF_OTA_SERVER_ABORTED = 3, - EMBER_AF_OTA_CLIENT_ABORTED = 4, - EMBER_AF_OTA_ERASE_FAILED = 5, +enum +{ + EMBER_AF_OTA_DOWNLOAD_AND_VERIFY_SUCCESS = 0, + EMBER_AF_OTA_DOWNLOAD_TIME_OUT = 1, + EMBER_AF_OTA_VERIFY_FAILED = 2, + EMBER_AF_OTA_SERVER_ABORTED = 3, + EMBER_AF_OTA_CLIENT_ABORTED = 4, + EMBER_AF_OTA_ERASE_FAILED = 5, }; typedef uint8_t EmberAfOtaDownloadResult; @@ -1247,147 +1287,137 @@ typedef uint8_t EmberAfOtaDownloadResult; * the Over-the-air header data that resides on disk. * It is not a byte-for-byte copy. */ -typedef struct { - // Magic Number omitted since it is always the same. - uint16_t headerVersion; - uint16_t headerLength; - uint16_t fieldControl; - uint16_t manufacturerId; - uint16_t imageTypeId; // a.k.a. Device ID - uint32_t firmwareVersion; - uint16_t zigbeeStackVersion; - - /** - * @brief The spec. does NOT require that the string be NULL terminated in the - * header stored on disk. Therefore we make sure we can support a - * 32-character string without a NULL terminator by adding +1 in the data - * structure. - */ - uint8_t headerString[EMBER_AF_OTA_MAX_HEADER_STRING_LENGTH + 1]; - - /** - * @brief When reading the header this will be the complete length of - * the file. When writing the header, this must be set to - * the length of the MFG image data portion including all tags. - */ - uint32_t imageSize; - - /** - * @brief The remaining four fields are optional. The field control should be checked - * to determine if their values are valid. - */ - uint8_t securityCredentials; - union { - uint8_t EUI64[EUI64_SIZE]; - uint8_t UID[UID_SIZE]; - } upgradeFileDestination; - uint16_t minimumHardwareVersion; - uint16_t maximumHardwareVersion; +typedef struct +{ + // Magic Number omitted since it is always the same. + uint16_t headerVersion; + uint16_t headerLength; + uint16_t fieldControl; + uint16_t manufacturerId; + uint16_t imageTypeId; // a.k.a. Device ID + uint32_t firmwareVersion; + uint16_t zigbeeStackVersion; + + /** + * @brief The spec. does NOT require that the string be NULL terminated in the + * header stored on disk. Therefore we make sure we can support a + * 32-character string without a NULL terminator by adding +1 in the data + * structure. + */ + uint8_t headerString[EMBER_AF_OTA_MAX_HEADER_STRING_LENGTH + 1]; + + /** + * @brief When reading the header this will be the complete length of + * the file. When writing the header, this must be set to + * the length of the MFG image data portion including all tags. + */ + uint32_t imageSize; + + /** + * @brief The remaining four fields are optional. The field control should be checked + * to determine if their values are valid. + */ + uint8_t securityCredentials; + union + { + uint8_t EUI64[EUI64_SIZE]; + uint8_t UID[UID_SIZE]; + } upgradeFileDestination; + uint16_t minimumHardwareVersion; + uint16_t maximumHardwareVersion; } EmberAfOtaHeader; /** * @brief This structure contains information about a tag that resides * within an Over-the-air bootload file. */ -typedef struct { - uint16_t id; - uint32_t length; +typedef struct +{ + uint16_t id; + uint32_t length; } EmberAfTagData; -typedef enum { - NO_APP_MESSAGE = 0, - RECEIVED_PARTNER_CERTIFICATE = 1, - GENERATING_EPHEMERAL_KEYS = 2, - GENERATING_SHARED_SECRET = 3, - KEY_GENERATION_DONE = 4, - GENERATE_SHARED_SECRET_DONE = 5, - /** - * LINK_KEY_ESTABLISHED indicates Success, - * key establishment done. - */ - LINK_KEY_ESTABLISHED = 6, - - /** - * Error codes: - * Transient failures where Key Establishment could be retried - */ - NO_LOCAL_RESOURCES = 7, - PARTNER_NO_RESOURCES = 8, - TIMEOUT_OCCURRED = 9, - INVALID_APP_COMMAND = 10, - MESSAGE_SEND_FAILURE = 11, - PARTNER_SENT_TERMINATE = 12, - INVALID_PARTNER_MESSAGE = 13, - PARTNER_SENT_DEFAULT_RESPONSE_ERROR = 14, - - /** - * Fatal Errors: - * These results are not worth retrying because the outcome - * will not change - */ - BAD_CERTIFICATE_ISSUER = 15, - KEY_CONFIRM_FAILURE = 16, - BAD_KEY_ESTABLISHMENT_SUITE = 17, - - KEY_TABLE_FULL = 18, - - /** - * Neither initiator nor responder is an - * ESP/TC so the key establishment is not - * allowed per the spec. - */ - NO_ESTABLISHMENT_ALLOWED = 19, - - /* 283k1 certificates need to have valid key usage - */ - INVALID_CERTIFICATE_KEY_USAGE = 20, +typedef enum +{ + NO_APP_MESSAGE = 0, + RECEIVED_PARTNER_CERTIFICATE = 1, + GENERATING_EPHEMERAL_KEYS = 2, + GENERATING_SHARED_SECRET = 3, + KEY_GENERATION_DONE = 4, + GENERATE_SHARED_SECRET_DONE = 5, + /** + * LINK_KEY_ESTABLISHED indicates Success, + * key establishment done. + */ + LINK_KEY_ESTABLISHED = 6, + + /** + * Error codes: + * Transient failures where Key Establishment could be retried + */ + NO_LOCAL_RESOURCES = 7, + PARTNER_NO_RESOURCES = 8, + TIMEOUT_OCCURRED = 9, + INVALID_APP_COMMAND = 10, + MESSAGE_SEND_FAILURE = 11, + PARTNER_SENT_TERMINATE = 12, + INVALID_PARTNER_MESSAGE = 13, + PARTNER_SENT_DEFAULT_RESPONSE_ERROR = 14, + + /** + * Fatal Errors: + * These results are not worth retrying because the outcome + * will not change + */ + BAD_CERTIFICATE_ISSUER = 15, + KEY_CONFIRM_FAILURE = 16, + BAD_KEY_ESTABLISHMENT_SUITE = 17, + + KEY_TABLE_FULL = 18, + + /** + * Neither initiator nor responder is an + * ESP/TC so the key establishment is not + * allowed per the spec. + */ + NO_ESTABLISHMENT_ALLOWED = 19, + + /* 283k1 certificates need to have valid key usage + */ + INVALID_CERTIFICATE_KEY_USAGE = 20, } EmberAfKeyEstablishmentNotifyMessage; #define APP_NOTIFY_ERROR_CODE_START NO_LOCAL_RESOURCES -#define APP_NOTIFY_MESSAGE_TEXT { \ - "None", \ - "Received Cert", \ - "Generate keys", \ - "Generate secret", \ - "Key generate done", \ - "Generate secret done", \ - "Link key verified", \ - \ - /* Transient Error codes */ \ - "No local resources", \ - "Partner no resources", \ - "Timeout", \ - "Invalid app. command", \ - "Message send failure", \ - "Partner sent terminate", \ - "Bad message", \ - "Partner sent Default Rsp", \ - \ - /* Fatal errors */ \ - "Bad cert issuer", \ - "Key confirm failure", \ - "Bad key est. suite", \ - "Key table full", \ - "Not allowed", \ - "Invalid Key Usage", \ -} +#define APP_NOTIFY_MESSAGE_TEXT \ + { \ + "None", "Received Cert", "Generate keys", "Generate secret", "Key generate done", "Generate secret done", \ + "Link key verified", \ + \ + /* Transient Error codes */ \ + "No local resources", "Partner no resources", "Timeout", "Invalid app. command", "Message send failure", \ + "Partner sent terminate", "Bad message", "Partner sent Default Rsp", \ + \ + /* Fatal errors */ \ + "Bad cert issuer", "Key confirm failure", "Bad key est. suite", "Key table full", "Not allowed", "Invalid Key Usage", \ + } /** * @brief This enumeration is used to indicate the state of an OTA bootload * image undergoing verification. This is used both for cryptographic * verification and manufacturer specific verification. */ -typedef enum { - EMBER_AF_IMAGE_GOOD = 0, - EMBER_AF_IMAGE_BAD = 1, - EMBER_AF_IMAGE_VERIFY_IN_PROGRESS = 2, +typedef enum +{ + EMBER_AF_IMAGE_GOOD = 0, + EMBER_AF_IMAGE_BAD = 1, + EMBER_AF_IMAGE_VERIFY_IN_PROGRESS = 2, #ifndef DOXYGEN_SHOULD_SKIP_THIS - // Internal use only. - EMBER_AF_IMAGE_VERIFY_WAIT = 3, - EMBER_AF_IMAGE_VERIFY_ERROR = 4, - EMBER_AF_IMAGE_UNKNOWN = 5, - EMBER_AF_NO_IMAGE_VERIFY_SUPPORT = 6, + // Internal use only. + EMBER_AF_IMAGE_VERIFY_WAIT = 3, + EMBER_AF_IMAGE_VERIFY_ERROR = 4, + EMBER_AF_IMAGE_UNKNOWN = 5, + EMBER_AF_NO_IMAGE_VERIFY_SUPPORT = 6, #endif } EmberAfImageVerifyStatus; @@ -1413,8 +1443,7 @@ typedef void (*EmberAfInitFunction)(uint8_t endpoint); * * This function is called just after an attribute changes. */ -typedef void (*EmberAfClusterAttributeChangedCallback)(uint8_t endpoint, - EmberAfAttributeId attributeId); +typedef void (*EmberAfClusterAttributeChangedCallback)(uint8_t endpoint, EmberAfAttributeId attributeId); /** * @brief Type for referring to the manufacturer specific @@ -1422,8 +1451,7 @@ typedef void (*EmberAfClusterAttributeChangedCallback)(uint8_t endpoint, * * This function is called just after a manufacturer specific attribute changes. */ -typedef void (*EmberAfManufacturerSpecificClusterAttributeChangedCallback)(uint8_t endpoint, - EmberAfAttributeId attributeId, +typedef void (*EmberAfManufacturerSpecificClusterAttributeChangedCallback)(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @@ -1431,11 +1459,9 @@ typedef void (*EmberAfManufacturerSpecificClusterAttributeChangedCallback)(uint8 * * This function is called before an attribute changes. */ -typedef EmberAfStatus (*EmberAfClusterPreAttributeChangedCallback)(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +typedef EmberAfStatus (*EmberAfClusterPreAttributeChangedCallback)(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** * @brief Type for referring to the default response callback function. @@ -1443,35 +1469,30 @@ typedef EmberAfStatus (*EmberAfClusterPreAttributeChangedCallback)(uint8_t endpo * This function is called when default response is received, before * the global callback. Global callback is called immediately afterwards. */ -typedef void (*EmberAfDefaultResponseFunction)(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +typedef void (*EmberAfDefaultResponseFunction)(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** * @brief Type for referring to the message sent callback function. * * This function is called when a message is sent. */ -typedef void (*EmberAfMessageSentFunction)(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +typedef void (*EmberAfMessageSentFunction)(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** * @brief The EmberAfMessageStruct is a struct wrapper that * contains all the data about a low-level message to be * sent (it may be ZCL or may be some other protocol). */ -typedef struct { - EmberAfMessageSentFunction callback; - EmberApsFrame* apsFrame; - uint8_t* message; - uint16_t indexOrDestination; - uint16_t messageLength; - EmberOutgoingMessageType type; - bool broadcast; +typedef struct +{ + EmberAfMessageSentFunction callback; + EmberApsFrame * apsFrame; + uint8_t * message; + uint16_t indexOrDestination; + uint16_t messageLength; + EmberOutgoingMessageType type; + bool broadcast; } EmberAfMessageStruct; /** @@ -1481,9 +1502,10 @@ typedef struct { * This key may be hashed and not the actual link key currently in use. */ -typedef struct { - EmberEUI64 deviceId; - EmberKeyData key; +typedef struct +{ + EmberEUI64 deviceId; + EmberKeyData key; } EmberAfLinkKeyBackupData; /** @@ -1496,11 +1518,12 @@ typedef struct { * indicating how many keys were actually written into 'keyList'. */ -typedef struct { - EmberEUI64 extendedPanId; - uint8_t keyListLength; - uint8_t maxKeyListLength; - EmberAfLinkKeyBackupData* keyList; +typedef struct +{ + EmberEUI64 extendedPanId; + uint8_t keyListLength; + uint8_t maxKeyListLength; + EmberAfLinkKeyBackupData * keyList; } EmberAfTrustCenterBackupData; /** @@ -1513,26 +1536,28 @@ typedef struct { * @brief A data struct for the information retrieved during a response * to an Ember Bootloader over-the-air query. */ -typedef struct { - uint8_t hardwareTag[EMBER_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH]; - uint8_t eui64[EUI64_SIZE]; - uint16_t mfgId; - uint16_t bootloaderVersion; - uint8_t capabilities; - uint8_t platform; - uint8_t micro; - uint8_t phy; - bool bootloaderActive; +typedef struct +{ + uint8_t hardwareTag[EMBER_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH]; + uint8_t eui64[EUI64_SIZE]; + uint16_t mfgId; + uint16_t bootloaderVersion; + uint8_t capabilities; + uint8_t platform; + uint8_t micro; + uint8_t phy; + bool bootloaderActive; } EmberAfStandaloneBootloaderQueryResponseData; /** * @brief A data struct used to keep track of incoming and outgoing * commands for command discovery */ -typedef struct { - uint16_t clusterId; - uint8_t commandId; - uint8_t mask; +typedef struct +{ + uint16_t clusterId; + uint8_t commandId; + uint8_t mask; } EmberAfCommandMetadata; /** @@ -1540,24 +1565,26 @@ typedef struct { * understandable format (as opposed to 32-bit UTC) */ -typedef struct { - uint16_t year; - uint8_t month; - uint8_t day; - uint8_t hours; - uint8_t minutes; - uint8_t seconds; +typedef struct +{ + uint16_t year; + uint8_t month; + uint8_t day; + uint8_t hours; + uint8_t minutes; + uint8_t seconds; } EmberAfTimeStruct; /** * @brief A data structure used to describe the ZCL Date data type */ -typedef struct { - uint8_t year; - uint8_t month; - uint8_t dayOfMonth; - uint8_t dayOfWeek; +typedef struct +{ + uint8_t year; + uint8_t month; + uint8_t dayOfMonth; + uint8_t dayOfWeek; } EmberAfDate; /* Simple Metering Server Test Code */ @@ -1566,78 +1593,78 @@ typedef struct { // Functional Notification Flags // Also #defined in enums.h under slightly different names -#define EMBER_AF_METERING_FNF_NEW_OTA_FIRMWARE 0x00000001 -#define EMBER_AF_METERING_FNF_CBKE_UPDATE_REQUEST 0x00000002 -#define EMBER_AF_METERING_FNF_TIME_SYNC 0x00000004 -#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_HAN 0x00000010 -#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_WAN 0x00000020 -#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET 0x000001C0 -#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET 0x00000E00 -#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER 0x00001000 -#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_METERING_CLUSTER 0x00002000 -#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER 0x00004000 -#define EMBER_AF_METERING_FNF_NETWORK_KEY_ACTIVE 0x00008000 -#define EMBER_AF_METERING_FNF_DISPLAY_MESSAGE 0x00010000 -#define EMBER_AF_METERING_FNF_CANCEL_ALL_MESSAGES 0x00020000 -#define EMBER_AF_METERING_FNF_CHANGE_SUPPLY 0x00040000 -#define EMBER_AF_METERING_FNF_LOCAL_CHANGE_SUPPLY 0x00080000 -#define EMBER_AF_METERING_FNF_SET_UNCONTROLLED_FLOW_THRESHOLD 0x00100000 -#define EMBER_AF_METERING_FNF_TUNNEL_MESSAGE_PENDING 0x00200000 -#define EMBER_AF_METERING_FNF_GET_SNAPSHOT 0x00400000 -#define EMBER_AF_METERING_FNF_GET_SAMPLED_DATA 0x00800000 -#define EMBER_AF_METERING_FNF_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE 0x01000000 -#define EMBER_AF_METERING_FNF_ENERGY_SCAN_PENDING 0x02000000 -#define EMBER_AF_METERING_FNF_CHANNEL_CHANGE_PENDING 0x04000000 +#define EMBER_AF_METERING_FNF_NEW_OTA_FIRMWARE 0x00000001 +#define EMBER_AF_METERING_FNF_CBKE_UPDATE_REQUEST 0x00000002 +#define EMBER_AF_METERING_FNF_TIME_SYNC 0x00000004 +#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_HAN 0x00000010 +#define EMBER_AF_METERING_FNF_STAY_AWAKE_REQUEST_WAN 0x00000020 +#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET 0x000001C0 +#define EMBER_AF_METERING_FNF_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET 0x00000E00 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER 0x00001000 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_METERING_CLUSTER 0x00002000 +#define EMBER_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER 0x00004000 +#define EMBER_AF_METERING_FNF_NETWORK_KEY_ACTIVE 0x00008000 +#define EMBER_AF_METERING_FNF_DISPLAY_MESSAGE 0x00010000 +#define EMBER_AF_METERING_FNF_CANCEL_ALL_MESSAGES 0x00020000 +#define EMBER_AF_METERING_FNF_CHANGE_SUPPLY 0x00040000 +#define EMBER_AF_METERING_FNF_LOCAL_CHANGE_SUPPLY 0x00080000 +#define EMBER_AF_METERING_FNF_SET_UNCONTROLLED_FLOW_THRESHOLD 0x00100000 +#define EMBER_AF_METERING_FNF_TUNNEL_MESSAGE_PENDING 0x00200000 +#define EMBER_AF_METERING_FNF_GET_SNAPSHOT 0x00400000 +#define EMBER_AF_METERING_FNF_GET_SAMPLED_DATA 0x00800000 +#define EMBER_AF_METERING_FNF_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE 0x01000000 +#define EMBER_AF_METERING_FNF_ENERGY_SCAN_PENDING 0x02000000 +#define EMBER_AF_METERING_FNF_CHANNEL_CHANGE_PENDING 0x04000000 // Notification Flags 2 -#define EMBER_AF_METERING_NF2_PUBLISH_PRICE 0x00000001 -#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_PERIOD 0x00000002 -#define EMBER_AF_METERING_NF2_PUBLISH_TARIFF_INFORMATION 0x00000004 -#define EMBER_AF_METERING_NF2_PUBLISH_CONVERSION_FACTOR 0x00000008 -#define EMBER_AF_METERING_NF2_PUBLISH_CALORIFIC_VALUE 0x00000010 -#define EMBER_AF_METERING_NF2_PUBLISH_CO2_VALUE 0x00000020 -#define EMBER_AF_METERING_NF2_PUBLISH_BILLING_PERIOD 0x00000040 -#define EMBER_AF_METERING_NF2_PUBLISH_CONSOLIDATED_BILL 0x00000080 -#define EMBER_AF_METERING_NF2_PUBLISH_PRICE_MATRIX 0x00000100 -#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_THRESHOLDS 0x00000200 -#define EMBER_AF_METERING_NF2_PUBLISH_CURRENCY_CONVERSION 0x00000400 -#define EMBER_AF_METERING_NF2_PUBLISH_CREDIT_PAYMENT_INFO 0x00001000 -#define EMBER_AF_METERING_NF2_PUBLISH_CPP_EVENT 0x00002000 -#define EMBER_AF_METERING_NF2_PUBLISH_TIER_LABELS 0x00004000 -#define EMBER_AF_METERING_NF2_CANCEL_TARIFF 0x00008000 +#define EMBER_AF_METERING_NF2_PUBLISH_PRICE 0x00000001 +#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_PERIOD 0x00000002 +#define EMBER_AF_METERING_NF2_PUBLISH_TARIFF_INFORMATION 0x00000004 +#define EMBER_AF_METERING_NF2_PUBLISH_CONVERSION_FACTOR 0x00000008 +#define EMBER_AF_METERING_NF2_PUBLISH_CALORIFIC_VALUE 0x00000010 +#define EMBER_AF_METERING_NF2_PUBLISH_CO2_VALUE 0x00000020 +#define EMBER_AF_METERING_NF2_PUBLISH_BILLING_PERIOD 0x00000040 +#define EMBER_AF_METERING_NF2_PUBLISH_CONSOLIDATED_BILL 0x00000080 +#define EMBER_AF_METERING_NF2_PUBLISH_PRICE_MATRIX 0x00000100 +#define EMBER_AF_METERING_NF2_PUBLISH_BLOCK_THRESHOLDS 0x00000200 +#define EMBER_AF_METERING_NF2_PUBLISH_CURRENCY_CONVERSION 0x00000400 +#define EMBER_AF_METERING_NF2_PUBLISH_CREDIT_PAYMENT_INFO 0x00001000 +#define EMBER_AF_METERING_NF2_PUBLISH_CPP_EVENT 0x00002000 +#define EMBER_AF_METERING_NF2_PUBLISH_TIER_LABELS 0x00004000 +#define EMBER_AF_METERING_NF2_CANCEL_TARIFF 0x00008000 // Notification Flags 3 -#define EMBER_AF_METERING_NF3_PUBLISH_CALENDAR 0x00000001 -#define EMBER_AF_METERING_NF3_PUBLISH_SPECIAL_DAYS 0x00000002 -#define EMBER_AF_METERING_NF3_PUBLISH_SEASONS 0x00000004 -#define EMBER_AF_METERING_NF3_PUBLISH_WEEK 0x00000008 -#define EMBER_AF_METERING_NF3_PUBLISH_DAY 0x00000010 -#define EMBER_AF_METERING_NF3_CANCEL_CALENDAR 0x00000020 +#define EMBER_AF_METERING_NF3_PUBLISH_CALENDAR 0x00000001 +#define EMBER_AF_METERING_NF3_PUBLISH_SPECIAL_DAYS 0x00000002 +#define EMBER_AF_METERING_NF3_PUBLISH_SEASONS 0x00000004 +#define EMBER_AF_METERING_NF3_PUBLISH_WEEK 0x00000008 +#define EMBER_AF_METERING_NF3_PUBLISH_DAY 0x00000010 +#define EMBER_AF_METERING_NF3_CANCEL_CALENDAR 0x00000020 // Notification Flags 4 -#define EMBER_AF_METERING_NF4_SELECT_AVAILABLE_EMERGENCY_CREDIT 0x00000001 -#define EMBER_AF_METERING_NF4_CHANGE_DEBT 0x00000002 -#define EMBER_AF_METERING_NF4_EMERGENCY_CREDIT_SETUP 0x00000004 -#define EMBER_AF_METERING_NF4_CONSUMER_TOP_UP 0x00000008 -#define EMBER_AF_METERING_NF4_CREDIT_ADJUSTMENT 0x00000010 -#define EMBER_AF_METERING_NF4_CHANGE_PAYMENT_MODE 0x00000020 -#define EMBER_AF_METERING_NF4_GET_PREPAY_SNAPSHOT 0x00000040 -#define EMBER_AF_METERING_NF4_GET_TOP_UP_LOG 0x00000080 -#define EMBER_AF_METERING_NF4_SET_LOW_CREDIT_WARNING_LEVEL 0x00000100 -#define EMBER_AF_METERING_NF4_GET_DEBT_REPAYMENT_LOG 0x00000200 -#define EMBER_AF_METERING_NF4_SET_MAXIMUM_CREDIT_LIMIT 0x00000400 -#define EMBER_AF_METERING_NF4_SET_OVERALL_DEBT_CAP 0x00000800 +#define EMBER_AF_METERING_NF4_SELECT_AVAILABLE_EMERGENCY_CREDIT 0x00000001 +#define EMBER_AF_METERING_NF4_CHANGE_DEBT 0x00000002 +#define EMBER_AF_METERING_NF4_EMERGENCY_CREDIT_SETUP 0x00000004 +#define EMBER_AF_METERING_NF4_CONSUMER_TOP_UP 0x00000008 +#define EMBER_AF_METERING_NF4_CREDIT_ADJUSTMENT 0x00000010 +#define EMBER_AF_METERING_NF4_CHANGE_PAYMENT_MODE 0x00000020 +#define EMBER_AF_METERING_NF4_GET_PREPAY_SNAPSHOT 0x00000040 +#define EMBER_AF_METERING_NF4_GET_TOP_UP_LOG 0x00000080 +#define EMBER_AF_METERING_NF4_SET_LOW_CREDIT_WARNING_LEVEL 0x00000100 +#define EMBER_AF_METERING_NF4_GET_DEBT_REPAYMENT_LOG 0x00000200 +#define EMBER_AF_METERING_NF4_SET_MAXIMUM_CREDIT_LIMIT 0x00000400 +#define EMBER_AF_METERING_NF4_SET_OVERALL_DEBT_CAP 0x00000800 // Notification Flags 5 -#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_TENANCY 0x00000001 -#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_SUPPLIER 0x00000002 -#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_1_RESPONSE 0x00000004 -#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_2_RESPONSE 0x00000008 -#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_3_RESPONSE 0x00000010 -#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_4_RESPONSE 0x00000020 -#define EMBER_AF_METERING_NF5_UPDATE_SITE_ID 0x00000040 -#define EMBER_AF_METERING_NF5_RESET_BATTERY_COUNTER 0x00000080 -#define EMBER_AF_METERING_NF5_UPDATE_CIN 0x00000100 +#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_TENANCY 0x00000001 +#define EMBER_AF_METERING_NF5_PUBLISH_CHANGE_OF_SUPPLIER 0x00000002 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_1_RESPONSE 0x00000004 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_2_RESPONSE 0x00000008 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_3_RESPONSE 0x00000010 +#define EMBER_AF_METERING_NF5_REQUEST_NEW_PASSWORD_4_RESPONSE 0x00000020 +#define EMBER_AF_METERING_NF5_UPDATE_SITE_ID 0x00000040 +#define EMBER_AF_METERING_NF5_RESET_BATTERY_COUNTER 0x00000080 +#define EMBER_AF_METERING_NF5_UPDATE_CIN 0x00000100 /** * @brief CBKE Library types @@ -1649,9 +1676,9 @@ typedef uint16_t EmberAfCbkeKeyEstablishmentSuite; enum #endif { - EMBER_AF_INVALID_KEY_ESTABLISHMENT_SUITE = 0x0000, - EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_163K1 = 0x0001, - EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_283K1 = 0x0002, + EMBER_AF_INVALID_KEY_ESTABLISHMENT_SUITE = 0x0000, + EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_163K1 = 0x0001, + EMBER_AF_CBKE_KEY_ESTABLISHMENT_SUITE_283K1 = 0x0002, }; /** @@ -1671,9 +1698,9 @@ typedef uint16_t EmberAfDeviceManagementPasswordType; enum #endif { - UNUSED_PASSWORD = 0x00, - SERVICE_PASSWORD = 0x01, - CONSUMER_PASSWORD = 0x02, + UNUSED_PASSWORD = 0x00, + SERVICE_PASSWORD = 0x01, + CONSUMER_PASSWORD = 0x02, }; #ifdef DOXYGEN_SHOULD_SKIP_THIS @@ -1683,102 +1710,113 @@ typedef uint8_t EmberAfDeviceManagementChangePendingFlags; enum #endif { - EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_TENANCY_PENDING_MASK = 0x01, - EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_SUPPLIER_PENDING_MASK = 0x02, - EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SITE_ID_PENDING_MASK = 0x04, - EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CIN_PENDING_MASK = 0x08, - EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SERVICE_PASSWORD_PENDING_MASK = 0x10, - EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CONSUMER_PASSWORD_PENDING_MASK = 0x20, + EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_TENANCY_PENDING_MASK = 0x01, + EMBER_AF_DEVICE_MANAGEMENT_CHANGE_OF_SUPPLIER_PENDING_MASK = 0x02, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SITE_ID_PENDING_MASK = 0x04, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CIN_PENDING_MASK = 0x08, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_SERVICE_PASSWORD_PENDING_MASK = 0x10, + EMBER_AF_DEVICE_MANAGEMENT_UPDATE_CONSUMER_PASSWORD_PENDING_MASK = 0x20, }; -typedef struct { - // Optional fields only used by Gas Proxy Function plugin. - uint32_t providerId; - uint32_t issuerEventId; - uint8_t tariffType; - - // always used fields - uint32_t implementationDateTime; - uint32_t tenancy; +typedef struct +{ + // Optional fields only used by Gas Proxy Function plugin. + uint32_t providerId; + uint32_t issuerEventId; + uint8_t tariffType; + + // always used fields + uint32_t implementationDateTime; + uint32_t tenancy; } EmberAfDeviceManagementTenancy; -typedef struct { - uint32_t proposedProviderId; - uint32_t implementationDateTime; - uint32_t providerChangeControl; - uint8_t proposedProviderName[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH + 1]; - uint8_t proposedProviderContactDetails[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH + 1]; +typedef struct +{ + uint32_t proposedProviderId; + uint32_t implementationDateTime; + uint32_t providerChangeControl; + uint8_t proposedProviderName[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH + 1]; + uint8_t proposedProviderContactDetails[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH + 1]; } EmberAfDeviceManagementSupplier; -typedef struct { - uint32_t requestDateTime; - uint32_t implementationDateTime; - uint8_t supplyStatus; - uint8_t originatorIdSupplyControlBits; +typedef struct +{ + uint32_t requestDateTime; + uint32_t implementationDateTime; + uint8_t supplyStatus; + uint8_t originatorIdSupplyControlBits; } EmberAfDeviceManagementSupply; -typedef struct { - uint8_t siteId[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH + 1]; - uint32_t implementationDateTime; - uint32_t issuerEventId; +typedef struct +{ + uint8_t siteId[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH + 1]; + uint32_t implementationDateTime; + uint32_t issuerEventId; } EmberAfDeviceManagementSiteId; -typedef struct { - uint8_t cin[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH + 1]; - uint32_t implementationDateTime; - uint32_t issuerEventId; +typedef struct +{ + uint8_t cin[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH + 1]; + uint32_t implementationDateTime; + uint32_t issuerEventId; } EmberAfDeviceManagementCIN; -typedef struct { - bool supplyTamperState; - bool supplyDepletionState; - bool supplyUncontrolledFlowState; - bool loadLimitSupplyState; +typedef struct +{ + bool supplyTamperState; + bool supplyDepletionState; + bool supplyUncontrolledFlowState; + bool loadLimitSupplyState; } EmberAfDeviceManagementSupplyStatusFlags; -typedef struct { - uint16_t uncontrolledFlowThreshold; - uint16_t multiplier; - uint16_t divisor; - uint16_t measurementPeriod; - uint8_t unitOfMeasure; - uint8_t stabilisationPeriod; +typedef struct +{ + uint16_t uncontrolledFlowThreshold; + uint16_t multiplier; + uint16_t divisor; + uint16_t measurementPeriod; + uint8_t unitOfMeasure; + uint8_t stabilisationPeriod; } EmberAfDeviceManagementUncontrolledFlowThreshold; -typedef struct { - uint32_t implementationDateTime; - uint8_t supplyStatus; +typedef struct +{ + uint32_t implementationDateTime; + uint8_t supplyStatus; } EmberAfDeviceManagementSupplyStatus; -typedef struct { - uint8_t password[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH + 1]; - uint32_t implementationDateTime; - uint16_t durationInMinutes; - EmberAfDeviceManagementPasswordType passwordType; +typedef struct +{ + uint8_t password[EMBER_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH + 1]; + uint32_t implementationDateTime; + uint16_t durationInMinutes; + EmberAfDeviceManagementPasswordType passwordType; } EmberAfDeviceManagementPassword; -typedef struct { - EmberAfDeviceManagementTenancy tenancy; - EmberAfDeviceManagementSupplier supplier; - EmberAfDeviceManagementSupply supply; - EmberAfDeviceManagementSiteId siteId; - EmberAfDeviceManagementCIN cin; - EmberAfDeviceManagementSupplyStatusFlags supplyStatusFlags; - EmberAfDeviceManagementSupplyStatus supplyStatus; - //TODO: These passwords ought to be tokenized / hashed - EmberAfDeviceManagementPassword servicePassword; - EmberAfDeviceManagementPassword consumerPassword; - EmberAfDeviceManagementUncontrolledFlowThreshold threshold; - uint32_t providerId; - uint32_t issuerEventId; - uint8_t proposedLocalSupplyStatus; - EmberAfTariffType tariffType; - EmberAfDeviceManagementChangePendingFlags pendingUpdates; +typedef struct +{ + EmberAfDeviceManagementTenancy tenancy; + EmberAfDeviceManagementSupplier supplier; + EmberAfDeviceManagementSupply supply; + EmberAfDeviceManagementSiteId siteId; + EmberAfDeviceManagementCIN cin; + EmberAfDeviceManagementSupplyStatusFlags supplyStatusFlags; + EmberAfDeviceManagementSupplyStatus supplyStatus; + // TODO: These passwords ought to be tokenized / hashed + EmberAfDeviceManagementPassword servicePassword; + EmberAfDeviceManagementPassword consumerPassword; + EmberAfDeviceManagementUncontrolledFlowThreshold threshold; + uint32_t providerId; + uint32_t issuerEventId; + uint8_t proposedLocalSupplyStatus; + EmberAfTariffType tariffType; + EmberAfDeviceManagementChangePendingFlags pendingUpdates; } EmberAfDeviceManagementInfo; -typedef struct { - uint8_t startIndex; - uint8_t endIndex; +typedef struct +{ + uint8_t startIndex; + uint8_t endIndex; } EmberAfDeviceManagementAttributeRange; // attrRange is a list of attributeId values in a cluster. It's needed to track contigous @@ -1787,27 +1825,30 @@ typedef struct { // to 0x08(OTA Event Configuration) // Eg. {0x00,0x05} and {0x08,0x0A} // We're betting that there isn't a list of cluster attributes that has more than 5 gaps. -typedef struct { - uint8_t attributeSetId; - EmberAfDeviceManagementAttributeRange attributeRange[7]; +typedef struct +{ + uint8_t attributeSetId; + EmberAfDeviceManagementAttributeRange attributeRange[7]; } EmberAfDeviceManagementAttributeTable; -typedef struct { - bool encryption; +typedef struct +{ + bool encryption; - uint8_t * plainPayload; - uint16_t plainPayloadLength; + uint8_t * plainPayload; + uint16_t plainPayloadLength; - uint8_t * encryptedPayload; - uint16_t encryptedPayloadLength; + uint8_t * encryptedPayload; + uint16_t encryptedPayloadLength; } EmberAfGbzMessageData; -typedef struct { - uint8_t * gbzCommands; - uint16_t gbzCommandsLength; - uint8_t * gbzCommandsResponse; - uint16_t gbzCommandsResponseLength; - uint16_t messageCode; +typedef struct +{ + uint8_t * gbzCommands; + uint16_t gbzCommandsLength; + uint8_t * gbzCommandsResponse; + uint16_t gbzCommandsResponseLength; + uint16_t messageCode; } EmberAfGpfMessage; /** @@ -1815,93 +1856,101 @@ typedef struct { */ typedef uint16_t EmberAfRemoteClusterType; -#define EMBER_AF_REMOTE_CLUSTER_TYPE_NONE 0x0000 -#define EMBER_AF_REMOTE_CLUSTER_TYPE_SERVER 0x0001 -#define EMBER_AF_REMOTE_CLUSTER_TYPE_CLIENT 0x0002 -#define EMBER_AF_REMOTE_CLUSTER_TYPE_INVALID 0xFFFF +#define EMBER_AF_REMOTE_CLUSTER_TYPE_NONE 0x0000 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_SERVER 0x0001 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_CLIENT 0x0002 +#define EMBER_AF_REMOTE_CLUSTER_TYPE_INVALID 0xFFFF /** * @brief Zigbee Internet Client/Server remote cluster struct. */ -typedef struct { - EmberAfClusterId clusterId; - EmberAfProfileId profileId; - uint16_t deviceId; - uint8_t endpoint; - EmberAfRemoteClusterType type; +typedef struct +{ + EmberAfClusterId clusterId; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; + EmberAfRemoteClusterType type; } EmberAfRemoteClusterStruct; /** * @brief Zigbee Internet Client/Server Remote Binding struct */ -typedef struct { - EmberEUI64 targetEUI64; - uint8_t sourceEndpoint; - uint8_t destEndpoint; - uint16_t clusterId; - EmberEUI64 destEUI64; - EmberEUI64 sourceEUI64; +typedef struct +{ + EmberEUI64 targetEUI64; + uint8_t sourceEndpoint; + uint8_t destEndpoint; + uint16_t clusterId; + EmberEUI64 destEUI64; + EmberEUI64 sourceEUI64; } EmberAfRemoteBindingStruct; -typedef struct { - EmberAfClusterId clusterId; - bool server; +typedef struct +{ + EmberAfClusterId clusterId; + bool server; } EmberAfClusterInfo; #if !defined(EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT) - #define EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT 3 +#define EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT 3 #endif /** * @brief A struct containing basic information about an endpoint. */ -typedef struct { - EmberAfClusterInfo clusters[EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT]; - EmberAfProfileId profileId; - uint16_t deviceId; - uint8_t endpoint; - uint8_t clusterCount; +typedef struct +{ + EmberAfClusterInfo clusters[EMBER_AF_MAX_CLUSTERS_PER_ENDPOINT]; + EmberAfProfileId profileId; + uint16_t deviceId; + uint8_t endpoint; + uint8_t clusterCount; } EmberAfEndpointInfoStruct; #if !defined(EMBER_AF_MAX_ENDPOINTS_PER_DEVICE) - #define EMBER_AF_MAX_ENDPOINTS_PER_DEVICE 1 +#define EMBER_AF_MAX_ENDPOINTS_PER_DEVICE 1 #endif // Although we treat this like a bitmap, only 1 bit is set at a time. // We use the bitmap feature to allow us to find all devices // with any in a set of status codes using // emberAfPluginDeviceDatabaseFindDeviceByStatus(). -typedef enum { - EMBER_AF_DEVICE_DISCOVERY_STATUS_NONE = 0x00, - EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW = 0x01, - EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS = 0x02, - EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS = 0x04, - EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_STACK_REVISION = 0x08, - - EMBER_AF_DEVICE_DISCOVERY_STATUS_DONE = 0x40, - EMBER_AF_DEVICE_DISCOVERY_STATUS_FAILED = 0x80, +typedef enum +{ + EMBER_AF_DEVICE_DISCOVERY_STATUS_NONE = 0x00, + EMBER_AF_DEVICE_DISCOVERY_STATUS_NEW = 0x01, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS = 0x02, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS = 0x04, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FIND_STACK_REVISION = 0x08, + + EMBER_AF_DEVICE_DISCOVERY_STATUS_DONE = 0x40, + EMBER_AF_DEVICE_DISCOVERY_STATUS_FAILED = 0x80, } EmberAfDeviceDiscoveryStatus; /** * @brief A struct containing endpoint information about a device. */ -typedef struct { - EmberEUI64 eui64; - EmberAfEndpointInfoStruct endpoints[EMBER_AF_MAX_ENDPOINTS_PER_DEVICE]; - EmberAfDeviceDiscoveryStatus status; - uint8_t discoveryFailures; - uint8_t capabilities; - uint8_t endpointCount; - uint8_t stackRevision; +typedef struct +{ + EmberEUI64 eui64; + EmberAfEndpointInfoStruct endpoints[EMBER_AF_MAX_ENDPOINTS_PER_DEVICE]; + EmberAfDeviceDiscoveryStatus status; + uint8_t discoveryFailures; + uint8_t capabilities; + uint8_t endpointCount; + uint8_t stackRevision; } EmberAfDeviceInfo; -typedef struct { - uint16_t deviceIndex; +typedef struct +{ + uint16_t deviceIndex; } EmberAfDeviceDatabaseIterator; -typedef struct { - EmberNodeId emberNodeId; - uint32_t timeStamp; +typedef struct +{ + EmberNodeId emberNodeId; + uint32_t timeStamp; } EmberAfJoiningDevice; #define EMBER_AF_INVALID_CLUSTER_ID 0xFFFF @@ -1913,7 +1962,7 @@ typedef struct { /** * @brief Permit join times */ -#define EMBER_AF_PERMIT_JOIN_FOREVER 0xFF +#define EMBER_AF_PERMIT_JOIN_FOREVER 0xFF #define EMBER_AF_PERMIT_JOIN_MAX_TIMEOUT 0xFE /** diff --git a/examples/wifi-echo/server/esp32/main/af.h b/examples/wifi-echo/server/esp32/main/af.h index 16017782369626..924efa8d7b86e0 100644 --- a/examples/wifi-echo/server/esp32/main/af.h +++ b/examples/wifi-echo/server/esp32/main/af.h @@ -31,11 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief The master include file for the Ember ApplicationFramework API. + * @brief The master include file for the Ember + *ApplicationFramework API. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ /** * @addtogroup af Zigbee Application Framework API Reference @@ -53,19 +55,19 @@ //#include PLATFORM_HEADER #ifndef CONFIGURATION_HEADER - #define CONFIGURATION_HEADER "config.h" +#define CONFIGURATION_HEADER "config.h" #endif #include CONFIGURATION_HEADER #ifdef EZSP_HOST // Includes needed for ember related functions for the EZSP host - #include "stack/include/error.h" - #include "stack/include/ember-types.h" - #include "stack/include/ember-random-api.h" - #include "app/util/ezsp/ezsp-protocol.h" - #include "app/util/ezsp/ezsp.h" - #include "app/util/ezsp/ezsp-utils.h" - #include "app/util/ezsp/serial-interface.h" +#include "app/util/ezsp/ezsp-protocol.h" +#include "app/util/ezsp/ezsp-utils.h" +#include "app/util/ezsp/ezsp.h" +#include "app/util/ezsp/serial-interface.h" +#include "stack/include/ember-random-api.h" +#include "stack/include/ember-types.h" +#include "stack/include/error.h" #else // Includes needed for ember related functions for the SoC // #include "stack/include/ember.h" @@ -80,9 +82,10 @@ #include "af-types.h" //#include "app/framework/util/print.h" //#include "app/framework/util/time-util.h" +#include "client-api.h" #include "gen/af-structs.h" -#include "gen/attribute-id.h" #include "gen/att-storage.h" +#include "gen/attribute-id.h" #include "gen/attribute-type.h" #include "gen/call-command-handler.h" #include "gen/callback.h" @@ -92,7 +95,6 @@ #include "gen/debug-printing.h" #include "gen/enums.h" #include "gen/print-cluster.h" -#include "client-api.h" //#include "app/util/serial/command-interpreter2.h" //#include "app/framework/cli/zcl-cli.h" @@ -112,22 +114,16 @@ * * @return Returns pointer to the attribute metadata location. */ -EmberAfAttributeMetadata *emberAfLocateAttributeMetadata(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode); +EmberAfAttributeMetadata * emberAfLocateAttributeMetadata(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** @brief Returns true if the attribute exists. */ -bool emberAfContainsAttribute(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, +bool emberAfContainsAttribute(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode); #else - #define emberAfContainsAttribute(endpoint, clusterId, attributeId, mask, manufacturerCode) \ - (emberAfLocateAttributeMetadata(endpoint, clusterId, attributeId, mask, manufacturerCode) != NULL) +#define emberAfContainsAttribute(endpoint, clusterId, attributeId, mask, manufacturerCode) \ + (emberAfLocateAttributeMetadata(endpoint, clusterId, attributeId, mask, manufacturerCode) != NULL) #endif /** @@ -217,12 +213,8 @@ bool emberAfContainsClient(uint8_t endpoint, EmberAfClusterId clusterId); * emberAfWriteManufacturerSpecificClientAttribute, * emberAfWriteManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief write a cluster server attribute. @@ -236,11 +228,8 @@ EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, * emberAfWriteManufacturerSpecificClientAttribute, * emberAfWriteManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief write a cluster client attribute. @@ -254,11 +243,8 @@ EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, * emberAfWriteManufacturerSpecificClientAttribute, * emberAfWriteManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief write a manufacturer specific server attribute. @@ -272,12 +258,9 @@ EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, * @see emberAfWriteClientAttribute, emberAfWriteServerAttribute, * emberAfWriteManufacturerSpecificClientAttribute */ -EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief write a manufacturer specific client attribute. @@ -291,12 +274,9 @@ EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, * @see emberAfWriteClientAttribute, emberAfWriteServerAttribute, * emberAfWriteManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief Function that test the success of attribute write. @@ -312,13 +292,8 @@ EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, * @param buffer Location where attribute will be written from. * @param dataType ZCL attribute type. */ -EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType); +EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * dataPtr, EmberAfAttributeType dataType); /** * @brief Read the attribute value, performing all the checks. @@ -332,13 +307,8 @@ EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, * emberAfReadManufacturerSpecificClientAttribute, * emberAfReadManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfReadAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint8_t* dataPtr, - uint8_t readLength, - EmberAfAttributeType* dataType); +EmberAfStatus emberAfReadAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint8_t * dataPtr, uint8_t readLength, EmberAfAttributeType * dataType); /** * @brief Read the server attribute value, performing all the checks. @@ -352,11 +322,8 @@ EmberAfStatus emberAfReadAttribute(uint8_t endpoint, * emberAfReadManufacturerSpecificClientAttribute, * emberAfReadManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - uint8_t readLength); +EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, uint8_t readLength); /** * @brief Read the client attribute value, performing all the checks. @@ -370,11 +337,8 @@ EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, * emberAfReadManufacturerSpecificClientAttribute, * emberAfReadManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - uint8_t readLength); +EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, uint8_t readLength); /** * @brief Read the manufacturer-specific server attribute value, performing all checks. @@ -387,12 +351,9 @@ EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, * @see emberAfReadClientAttribute, emberAfReadServerAttribute, * emberAfReadManufacturerSpecificClientAttribute */ -EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - uint8_t readLength); +EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, uint8_t readLength); /** * @brief Read the manufacturer-specific client attribute value, performing all checks. @@ -405,12 +366,9 @@ EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, * @see emberAfReadClientAttribute, emberAfReadServerAttribute, * emberAfReadManufacturerSpecificServerAttribute */ -EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - uint8_t readLength); +EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, uint8_t readLength); /** * @brief this function returns the size of the ZCL data in bytes. @@ -484,7 +442,7 @@ extern EmberAfDefinedEndpoint emAfEndpoints[]; extern const EmAfZigbeeProNetwork emAfZigbeeProNetworks[]; // The current zigbee PRO network or NULL. -extern const EmAfZigbeeProNetwork *emAfCurrentZigbeeProNetwork; +extern const EmAfZigbeeProNetwork * emAfCurrentZigbeeProNetwork; // true if the current network is a zigbee PRO network. #define emAfProIsCurrentNetwork() (emAfCurrentZigbeeProNetwork != NULL) @@ -548,7 +506,7 @@ uint8_t emberAfNetworkIndexFromEndpoint(uint8_t endpoint); * Primary profile is the profile of a primary endpoint as defined * in AppBuilder. */ -#define emberAfPrimaryProfileId() emberAfProfileIdFromIndex(0) +#define emberAfPrimaryProfileId() emberAfProfileIdFromIndex(0) /** * @brief Macro that returns the primary endpoint. @@ -569,10 +527,11 @@ uint8_t emberAfFixedEndpointCount(void); * Data types are either analog or discrete. This makes a difference for * some of the ZCL global commands */ -enum { - EMBER_AF_DATA_TYPE_ANALOG = 0, - EMBER_AF_DATA_TYPE_DISCRETE = 1, - EMBER_AF_DATA_TYPE_NONE = 2 +enum +{ + EMBER_AF_DATA_TYPE_ANALOG = 0, + EMBER_AF_DATA_TYPE_DISCRETE = 1, + EMBER_AF_DATA_TYPE_NONE = 2 }; /** @@ -588,30 +547,30 @@ bool emberAfIsTypeSigned(EmberAfAttributeType dataType); /** * @brief Function that extracts a 32-bit integer from the message buffer */ -uint32_t emberAfGetInt32u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +uint32_t emberAfGetInt32u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen); /** * @brief Function that extracts a 24-bit integer from the message buffer */ -uint32_t emberAfGetInt24u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +uint32_t emberAfGetInt24u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen); /** * @brief Function that extracts a 16-bit integer from the message buffer */ -uint16_t emberAfGetInt16u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +uint16_t emberAfGetInt16u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen); /** * @brief Function that extracts a ZCL string from the message buffer */ -uint8_t* emberAfGetString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +uint8_t * emberAfGetString(uint8_t * message, uint16_t currentIndex, uint16_t msgLen); /** * @brief Function that extracts a ZCL long string from the message buffer */ -uint8_t* emberAfGetLongString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen); +uint8_t * emberAfGetLongString(uint8_t * message, uint16_t currentIndex, uint16_t msgLen); /* * @brief Function that extracts a ZCL Date from the message buffer and returns it * in the given destination. Returns the number of bytes copied. */ -uint8_t emberAfGetDate(uint8_t* message, uint16_t currentIndex, uint16_t msgLen, EmberAfDate *destination); +uint8_t emberAfGetDate(uint8_t * message, uint16_t currentIndex, uint16_t msgLen, EmberAfDate * destination); /** * @brief Macro for consistency, that extracts single byte out of the message @@ -625,37 +584,37 @@ uint8_t emberAfGetDate(uint8_t* message, uint16_t currentIndex, uint16_t msgLen, /** * @brief function that copies a uint16_t value into a buffer */ -void emberAfCopyInt16u(uint8_t *data, uint16_t index, uint16_t x); +void emberAfCopyInt16u(uint8_t * data, uint16_t index, uint16_t x); /** * @brief function that copies a uint24_t value into a buffer */ -void emberAfCopyInt24u(uint8_t *data, uint16_t index, uint32_t x); +void emberAfCopyInt24u(uint8_t * data, uint16_t index, uint32_t x); /** * @brief function that copies a uint32_t value into a buffer */ -void emberAfCopyInt32u(uint8_t *data, uint16_t index, uint32_t x); +void emberAfCopyInt32u(uint8_t * data, uint16_t index, uint32_t x); /* * @brief Function that copies a ZCL string type into a buffer. The size * parameter should indicate the maximum number of characters to copy to the * destination buffer not including the length byte. */ -void emberAfCopyString(uint8_t *dest, uint8_t *src, uint8_t size); +void emberAfCopyString(uint8_t * dest, uint8_t * src, uint8_t size); /* * @brief Function that copies a ZCL long string into a buffer. The size * parameter should indicate the maximum number of characters to copy to the * destination buffer not including the length bytes. */ -void emberAfCopyLongString(uint8_t *dest, uint8_t *src, uint16_t size); +void emberAfCopyLongString(uint8_t * dest, uint8_t * src, uint16_t size); /* * @brief Function that determines the length of a zigbee Cluster Library string * (where the first byte is assumed to be the length). */ -uint8_t emberAfStringLength(const uint8_t *buffer); +uint8_t emberAfStringLength(const uint8_t * buffer); /* * @brief Function that determines the length of a zigbee Cluster Library long string. * (where the first two bytes are assumed to be the length). */ -uint16_t emberAfLongStringLength(const uint8_t *buffer); +uint16_t emberAfLongStringLength(const uint8_t * buffer); /* * @brief Function that determines the size of a zigbee Cluster Library @@ -663,8 +622,7 @@ uint16_t emberAfLongStringLength(const uint8_t *buffer); * string). For strings, the size includes the length of the string plus the * number of the string's length prefix byte(s). */ -uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, - const uint8_t *buffer); +uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, const uint8_t * buffer); /** @} END Attribute Storage */ @@ -725,7 +683,7 @@ bool emberAfEndpointIndexIsEnabled(uint8_t index); * @brief This indicates the continuation of an image verification already * in progress. */ -#define EMBER_AF_CONTINUE_IMAGE_VERIFY false +#define EMBER_AF_CONTINUE_IMAGE_VERIFY false /** * @brief This variable defines an invalid image id. It is used @@ -796,7 +754,7 @@ uint8_t emberAfGetLastSequenceNumber(void); * greater than 4 is being compared * 1, if val2 is smaller. */ -int8_t emberAfCompareValues(uint8_t* val1, uint8_t* val2, uint8_t len, bool signedNumber); +int8_t emberAfCompareValues(uint8_t * val1, uint8_t * val2, uint8_t len, bool signedNumber); /** * @brief populates the passed EUI64 with the local EUI64 MAC address. @@ -806,7 +764,7 @@ void emberAfGetEui64(EmberEUI64 returnEui64); #ifdef EZSP_HOST // Normally this is provided by the stack code, but on the host // it is provided by the application code. -void emberReverseMemCopy(uint8_t* dest, const uint8_t* src, uint16_t length); +void emberReverseMemCopy(uint8_t * dest, const uint8_t * src, uint16_t length); #endif /** @@ -818,9 +776,9 @@ EmberNodeId emberAfGetNodeId(void); /** * @brief Generates a random key (link, network, or master). */ -EmberStatus emberAfGenerateRandomKey(EmberKeyData *result); +EmberStatus emberAfGenerateRandomKey(EmberKeyData * result); #else - #define emberAfGenerateRandomKey(result) emberGenerateRandomKey(result) +#define emberAfGenerateRandomKey(result) emberGenerateRandomKey(result) #endif /** @@ -859,23 +817,22 @@ uint8_t emberAfGetRadioChannel(void); /** * @brief Returns the current network parameters. */ -EmberStatus emberAfGetNetworkParameters(EmberNodeType *nodeType, - EmberNetworkParameters *parameters); +EmberStatus emberAfGetNetworkParameters(EmberNodeType * nodeType, EmberNetworkParameters * parameters); /** * @brief Returns the current node type. */ -EmberStatus emberAfGetNodeType(EmberNodeType *nodeType); +EmberStatus emberAfGetNodeType(EmberNodeType * nodeType); /** */ -#define EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE 0xA0 -#define EMBER_AF_REJOIN_DUE_TO_TC_KEEPALIVE_FAILURE 0xA1 -#define EMBER_AF_REJOIN_DUE_TO_CLI_COMMAND 0xA2 -#define EMBER_AF_REJOIN_DUE_TO_WWAH_CONNECTIVITY_MANAGER 0xA3 +#define EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE 0xA0 +#define EMBER_AF_REJOIN_DUE_TO_TC_KEEPALIVE_FAILURE 0xA1 +#define EMBER_AF_REJOIN_DUE_TO_CLI_COMMAND 0xA2 +#define EMBER_AF_REJOIN_DUE_TO_WWAH_CONNECTIVITY_MANAGER 0xA3 -#define EMBER_AF_REJOIN_FIRST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE -#define EMBER_AF_REJOIN_LAST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE +#define EMBER_AF_REJOIN_FIRST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE +#define EMBER_AF_REJOIN_LAST_REASON EMBER_AF_REJOIN_DUE_TO_END_DEVICE_MOVE /** * @brief Enables local permit join and optionally broadcasts the ZDO @@ -890,8 +847,7 @@ EmberStatus emberAfGetNodeType(EmberNodeType *nodeType); * * @returns status of whether or not permit join was enabled. */ -EmberStatus emberAfPermitJoin(uint8_t duration, - bool broadcastMgmtPermitJoin); +EmberStatus emberAfPermitJoin(uint8_t duration, bool broadcastMgmtPermitJoin); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** @@ -907,8 +863,7 @@ EmberStatus emberAfPermitJoin(uint8_t duration, */ EmberStatus emberAfBroadcastPermitJoin(uint8_t duration); #else - #define emberAfBroadcastPermitJoin(duration) \ - emberAfPermitJoin((duration), true) +#define emberAfBroadcastPermitJoin(duration) emberAfPermitJoin((duration), true) #endif /** @} END Miscellaneous */ @@ -919,14 +874,12 @@ EmberStatus emberAfBroadcastPermitJoin(uint8_t duration); /** * @brief A function used to add a task to the task register. */ -#define emberAfAddToCurrentAppTasks(x) \ - emberAfAddToCurrentAppTasksCallback(x) +#define emberAfAddToCurrentAppTasks(x) emberAfAddToCurrentAppTasksCallback(x) /** * @brief A function used to remove a task from the task register. */ -#define emberAfRemoveFromCurrentAppTasks(x) \ - emberAfRemoveFromCurrentAppTasksCallback(x) +#define emberAfRemoveFromCurrentAppTasks(x) emberAfRemoveFromCurrentAppTasksCallback(x) /** * @brief A macro used to retrieve the bitmask of all application @@ -977,12 +930,8 @@ void emberAfRunEvents(void); * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleTickExtended(uint8_t endpoint, - EmberAfClusterId clusterId, - bool isClient, - uint32_t delayMs, - EmberAfEventPollControl pollControl, - EmberAfEventSleepControl sleepControl); +EmberStatus emberAfScheduleTickExtended(uint8_t endpoint, EmberAfClusterId clusterId, bool isClient, uint32_t delayMs, + EmberAfEventPollControl pollControl, EmberAfEventSleepControl sleepControl); /** * @brief This function is used to schedule a cluster-related event inside the @@ -1003,10 +952,7 @@ EmberStatus emberAfScheduleTickExtended(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleClusterTick(uint8_t endpoint, - EmberAfClusterId clusterId, - bool isClient, - uint32_t delayMs, +EmberStatus emberAfScheduleClusterTick(uint8_t endpoint, EmberAfClusterId clusterId, bool isClient, uint32_t delayMs, EmberAfEventSleepControl sleepControl); /** @@ -1023,11 +969,8 @@ EmberStatus emberAfScheduleClusterTick(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleClientTickExtended(uint8_t endpoint, - EmberAfClusterId clusterId, - uint32_t delayMs, - EmberAfEventPollControl pollControl, - EmberAfEventSleepControl sleepControl); +EmberStatus emberAfScheduleClientTickExtended(uint8_t endpoint, EmberAfClusterId clusterId, uint32_t delayMs, + EmberAfEventPollControl pollControl, EmberAfEventSleepControl sleepControl); /** * @brief A function used to schedule a cluster client event. This function @@ -1040,9 +983,7 @@ EmberStatus emberAfScheduleClientTickExtended(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleClientTick(uint8_t endpoint, - EmberAfClusterId clusterId, - uint32_t delayMs); +EmberStatus emberAfScheduleClientTick(uint8_t endpoint, EmberAfClusterId clusterId, uint32_t delayMs); /** * @brief A function used to schedule a cluster server event. This function @@ -1058,11 +999,8 @@ EmberStatus emberAfScheduleClientTick(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleServerTickExtended(uint8_t endpoint, - EmberAfClusterId clusterId, - uint32_t delayMs, - EmberAfEventPollControl pollControl, - EmberAfEventSleepControl sleepControl); +EmberStatus emberAfScheduleServerTickExtended(uint8_t endpoint, EmberAfClusterId clusterId, uint32_t delayMs, + EmberAfEventPollControl pollControl, EmberAfEventSleepControl sleepControl); /** * @brief A function used to schedule a cluster server event. This function @@ -1075,9 +1013,7 @@ EmberStatus emberAfScheduleServerTickExtended(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was scheduled or an error otherwise. */ -EmberStatus emberAfScheduleServerTick(uint8_t endpoint, - EmberAfClusterId clusterId, - uint32_t delayMs); +EmberStatus emberAfScheduleServerTick(uint8_t endpoint, EmberAfClusterId clusterId, uint32_t delayMs); /** * @brief A function used to deactivate a cluster-related event. This function @@ -1093,9 +1029,7 @@ EmberStatus emberAfScheduleServerTick(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. */ -EmberStatus emberAfDeactivateClusterTick(uint8_t endpoint, - EmberAfClusterId clusterId, - bool isClient); +EmberStatus emberAfDeactivateClusterTick(uint8_t endpoint, EmberAfClusterId clusterId, bool isClient); /** * @brief A function used to deactivate a cluster client event. This function @@ -1106,8 +1040,7 @@ EmberStatus emberAfDeactivateClusterTick(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. */ -EmberStatus emberAfDeactivateClientTick(uint8_t endpoint, - EmberAfClusterId clusterId); +EmberStatus emberAfDeactivateClientTick(uint8_t endpoint, EmberAfClusterId clusterId); /** * @brief A function used to deactivate a cluster server event. This function @@ -1118,8 +1051,7 @@ EmberStatus emberAfDeactivateClientTick(uint8_t endpoint, * * @return EMBER_SUCCESS if the event was deactivated or an error otherwise. */ -EmberStatus emberAfDeactivateServerTick(uint8_t endpoint, - EmberAfClusterId clusterId); +EmberStatus emberAfDeactivateServerTick(uint8_t endpoint, EmberAfClusterId clusterId); /** * @brief Sets the ::EmberEventControl to run "delayMs" milliseconds in the @@ -1134,19 +1066,16 @@ EmberStatus emberAfDeactivateServerTick(uint8_t endpoint, event and return ::EMBER_SUCCESS. Otherwise it will return ::EMBER_BAD_ARGUMENT. */ -EmberStatus emberAfEventControlSetDelayMS(EmberEventControl *control, - uint32_t delayMs); +EmberStatus emberAfEventControlSetDelayMS(EmberEventControl * control, uint32_t delayMs); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** * @brief Sets the ::EmberEventControl to run "delayMs" milliseconds in the * future. See ::emberAfEventControlSetDelayMS. */ -EmberStatus emberAfEventControlSetDelay(EmberEventControl *eventControl, - uint32_t delayMs); +EmberStatus emberAfEventControlSetDelay(EmberEventControl * eventControl, uint32_t delayMs); #else -#define emberAfEventControlSetDelay(control, delayMs) \ - emberAfEventControlSetDelayMS(control, delayMs) +#define emberAfEventControlSetDelay(control, delayMs) emberAfEventControlSetDelayMS(control, delayMs) #endif /** @@ -1163,8 +1092,7 @@ EmberStatus emberAfEventControlSetDelay(EmberEventControl *eventControl, event and return ::EMBER_SUCCESS. Otherwise it will return ::EMBER_BAD_ARGUMENT. */ -EmberStatus emberAfEventControlSetDelayQS(EmberEventControl *control, - uint32_t delayQs); +EmberStatus emberAfEventControlSetDelayQS(EmberEventControl * control, uint32_t delayQs); /** * @brief Sets the ::EmberEventControl to run "delayM" minutes in the future. @@ -1180,111 +1108,94 @@ EmberStatus emberAfEventControlSetDelayQS(EmberEventControl *control, the event and return ::EMBER_SUCCESS. Otherwise it will return ::EMBER_BAD_ARGUMENT. */ -EmberStatus emberAfEventControlSetDelayMinutes(EmberEventControl *control, - uint16_t delayM); +EmberStatus emberAfEventControlSetDelayMinutes(EmberEventControl * control, uint16_t delayM); /** * @brief Sets the ::EmberEventControl for the current network, and only * the current network, as inactive. See ::emberEventControlSetInactive. */ -void emberAfNetworkEventControlSetInactive(EmberEventControl *controls); +void emberAfNetworkEventControlSetInactive(EmberEventControl * controls); /** * @brief Returns true if the event for the current network, and only the * current network, is active. See ::emberEventControlGetActive. */ -bool emberAfNetworkEventControlGetActive(EmberEventControl *controls); +bool emberAfNetworkEventControlGetActive(EmberEventControl * controls); /** * @brief Sets the ::EmberEventControl for the current network, and only * current network, to run at the next available opportunity. See * ::emberEventControlSetActive. */ -void emberAfNetworkEventControlSetActive(EmberEventControl *controls); +void emberAfNetworkEventControlSetActive(EmberEventControl * controls); /** * @brief Sets the ::EmberEventControl for the current network, and only the * current network, to run "delayMs" milliseconds in the future. See * ::emberAfEventControlSetDelayMS. */ -EmberStatus emberAfNetworkEventControlSetDelayMS(EmberEventControl *controls, - uint32_t delayMs); +EmberStatus emberAfNetworkEventControlSetDelayMS(EmberEventControl * controls, uint32_t delayMs); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** * @brief Sets the ::EmberEventControl for the current network, and only the * current network, to run "delayMs" milliseconds in the future. See * ::emberAfEventControlSetDelayMS. */ -EmberStatus emberAfNetworkEventControlSetDelay(EmberEventControl *controls, - uint32_t delayMs); +EmberStatus emberAfNetworkEventControlSetDelay(EmberEventControl * controls, uint32_t delayMs); #else -#define emberAfNetworkEventControlSetDelay(controls, delayMs) \ - emberAfNetworkEventControlSetDelayMS(controls, delayMs); +#define emberAfNetworkEventControlSetDelay(controls, delayMs) emberAfNetworkEventControlSetDelayMS(controls, delayMs); #endif /** * @brief Sets the ::EmberEventControl for the current network, and only the * current network, to run "delayQs" quarter seconds in the future. See * ::emberAfEventControlSetDelayQS. */ -EmberStatus emberAfNetworkEventControlSetDelayQS(EmberEventControl *controls, - uint32_t delayQs); +EmberStatus emberAfNetworkEventControlSetDelayQS(EmberEventControl * controls, uint32_t delayQs); /** * @brief Sets the ::EmberEventControl for the current network, and only the * current network, to run "delayM" minutes in the future. See * ::emberAfEventControlSetDelayMinutes. */ -EmberStatus emberAfNetworkEventControlSetDelayMinutes(EmberEventControl *controls, - uint16_t delayM); +EmberStatus emberAfNetworkEventControlSetDelayMinutes(EmberEventControl * controls, uint16_t delayM); /** * @brief Sets the ::EmberEventControl for the specified endpoint as inactive. * See ::emberEventControlSetInactive. */ -EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl *controls, - uint8_t endpoint); +EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl * controls, uint8_t endpoint); /** * @brief Returns true if the event for the current number is active. See * ::emberEventControlGetActive. */ -bool emberAfEndpointEventControlGetActive(EmberEventControl *controls, - uint8_t endpoint); +bool emberAfEndpointEventControlGetActive(EmberEventControl * controls, uint8_t endpoint); /** * @brief Sets the ::EmberEventControl for the specified endpoint to run at the * next available opportunity. See ::emberEventControlSetActive. */ -EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, - uint8_t endpoint); +EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl * controls, uint8_t endpoint); /** * @brief Sets the ::EmberEventControl for the specified endpoint to run * "delayMs" milliseconds in the future. See ::emberAfEventControlSetDelayMS. */ -EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl *controls, - uint8_t endpoint, - uint32_t delayMs); +EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl * controls, uint8_t endpoint, uint32_t delayMs); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** * @brief Sets the ::EmberEventControl for the specified endpoint to run * "delayMs" milliseconds in the future. See ::emberAfEventControlSetDelayMS. */ -EmberStatus emberAfEndpointEventControlSetDelay(EmberEventControl *controls, - uint8_t endpoint, - uint32_t delayMs); +EmberStatus emberAfEndpointEventControlSetDelay(EmberEventControl * controls, uint8_t endpoint, uint32_t delayMs); #else -#define emberAfEndpointEventControlSetDelay(controls, endpoint, delayMs) \ - emberAfEndpointEventControlSetDelayMS(controls, endpoint, delayMs); +#define emberAfEndpointEventControlSetDelay(controls, endpoint, delayMs) \ + emberAfEndpointEventControlSetDelayMS(controls, endpoint, delayMs); #endif /** * @brief Sets the ::EmberEventControl for the specified endpoint to run * "delayQs" quarter seconds in the future. See * ::emberAfEventControlSetDelayQS. */ -EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl *controls, - uint8_t endpoint, - uint32_t delayQs); +EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl * controls, uint8_t endpoint, uint32_t delayQs); /** * @brief Sets the ::EmberEventControl for the specified endpoint to run * "delayM" minutes in the future. See ::emberAfEventControlSetDelayMinutes. */ -EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl *controls, - uint8_t endpoint, - uint16_t delayM); +EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl * controls, uint8_t endpoint, uint16_t delayM); /** * @brief A function used to retrieve the number of milliseconds until @@ -1301,7 +1212,7 @@ uint32_t emberAfMsToNextEvent(uint32_t maxMs); * following addition. If returnIndex is non-NULL it returns the index * of the event that is ready to fire next. */ -uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); +uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t * returnIndex); /** * @brief A function used to retrieve the number of quarter seconds until @@ -1313,9 +1224,8 @@ uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); * @return The number of quarter seconds until the next event or * maxQS if no event is scheduled before then. */ -#define emberAfQSToNextEvent(maxQS) \ - (emberAfMsToNextEvent(maxQS * MILLISECOND_TICKS_PER_QUARTERSECOND) \ - / MILLISECOND_TICKS_PER_QUARTERSECOND) +#define emberAfQSToNextEvent(maxQS) \ + (emberAfMsToNextEvent(maxQS * MILLISECOND_TICKS_PER_QUARTERSECOND) / MILLISECOND_TICKS_PER_QUARTERSECOND) /** * @brief A function for retrieving the most restrictive sleep @@ -1331,8 +1241,7 @@ uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); * EMBER_AF_OK_TO_HIBERNATE but can be changed at any * time using the emberAfSetDefaultSleepControl() function. */ -#define emberAfGetCurrentSleepControl() \ - emberAfGetCurrentSleepControlCallback() +#define emberAfGetCurrentSleepControl() emberAfGetCurrentSleepControlCallback() /** * @brief A function for setting the default sleep control @@ -1343,8 +1252,7 @@ uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); * the value to EMBER_AF_OK_TO_HIBERNATE once the wake * period is complete. */ -#define emberAfSetDefaultSleepControl(x) \ - emberAfSetDefaultSleepControlCallback(x) +#define emberAfSetDefaultSleepControl(x) emberAfSetDefaultSleepControlCallback(x) /** * @brief A function used to retrieve the default sleep control against @@ -1354,8 +1262,7 @@ uint32_t emberAfMsToNextEventExtended(uint32_t maxMs, uint8_t* returnIndex); * at any time using the emberAfSetDefaultSleepControl() function. * @return The current default sleep control value. */ -#define emberAfGetDefaultSleepControl() \ - emberAfGetDefaultSleepControlCallback() +#define emberAfGetDefaultSleepControl() emberAfGetDefaultSleepControlCallback() /** @} END Sleep Control */ @@ -1384,10 +1291,7 @@ EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) /** * @brief Sends multicast. */ -EmberStatus emberAfSendMulticast(EmberMulticastId multicastId, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfSendMulticast(EmberMulticastId multicastId, EmberApsFrame * apsFrame, uint16_t messageLength, uint8_t * message); /** * @brief Multicasts the message to the group in the binding table that @@ -1396,76 +1300,50 @@ EmberStatus emberAfSendMulticast(EmberMulticastId multicastId, * significant amount of network traffic. Care should be taken when considering * the effects of broadcasts in a network. */ -EmberStatus emberAfSendMulticastToBindings(EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfSendMulticastToBindings(EmberApsFrame * apsFrame, uint16_t messageLength, uint8_t * message); /** * @brief Sends Multicast with alias with attached message sent callback */ -EmberStatus emberAfSendMulticastWithAliasWithCallback(EmberMulticastId multicastId, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t *message, - EmberNodeId alias, - uint8_t sequence, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendMulticastWithAliasWithCallback(EmberMulticastId multicastId, EmberApsFrame * apsFrame, + uint16_t messageLength, uint8_t * message, EmberNodeId alias, + uint8_t sequence, EmberAfMessageSentFunction callback); /** * @brief Sends multicast with attached message sent callback. */ -EmberStatus emberAfSendMulticastWithCallback(EmberMulticastId multicastId, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendMulticastWithCallback(EmberMulticastId multicastId, EmberApsFrame * apsFrame, uint16_t messageLength, + uint8_t * message, EmberAfMessageSentFunction callback); /** * @brief Sends broadcast. */ -EmberStatus emberAfSendBroadcast(EmberNodeId destination, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfSendBroadcast(EmberNodeId destination, EmberApsFrame * apsFrame, uint16_t messageLength, uint8_t * message); /** * @brief Sends broadcast with attached message sent callback. */ -EmberStatus emberAfSendBroadcastWithCallback(EmberNodeId destination, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendBroadcastWithCallback(EmberNodeId destination, EmberApsFrame * apsFrame, uint16_t messageLength, + uint8_t * message, EmberAfMessageSentFunction callback); /** * @brief Sends broadcast with alias with attached message sent callback. */ -EmberStatus emberAfSendBroadcastWithAliasWithCallback(EmberNodeId destination, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t *message, - EmberNodeId alias, - uint8_t sequence, +EmberStatus emberAfSendBroadcastWithAliasWithCallback(EmberNodeId destination, EmberApsFrame * apsFrame, uint16_t messageLength, + uint8_t * message, EmberNodeId alias, uint8_t sequence, EmberAfMessageSentFunction callback); /** * @brief Sends unicast. */ -EmberStatus emberAfSendUnicast(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfSendUnicast(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t messageLength, uint8_t * message); /** * @brief Sends unicast with attached message sent callback. */ -EmberStatus emberAfSendUnicastWithCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendUnicastWithCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t messageLength, uint8_t * message, EmberAfMessageSentFunction callback); /** * @brief Unicasts the message to each remote node in the binding table that @@ -1473,29 +1351,20 @@ EmberStatus emberAfSendUnicastWithCallback(EmberOutgoingMessageType type, * binding table contains many matching entries, calling this API cause a * significant amount of network traffic. */ -EmberStatus emberAfSendUnicastToBindings(EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfSendUnicastToBindings(EmberApsFrame * apsFrame, uint16_t messageLength, uint8_t * message); /** * @brief emberAfSendUnicastToBindings with attached message sent callback. */ -EmberStatus emberAfSendUnicastToBindingsWithCallback(EmberApsFrame *apsFrame, - uint16_t messageLength, - uint8_t* message, +EmberStatus emberAfSendUnicastToBindingsWithCallback(EmberApsFrame * apsFrame, uint16_t messageLength, uint8_t * message, EmberAfMessageSentFunction callback); /** * @brief Sends interpan message. */ -EmberStatus emberAfSendInterPan(EmberPanId panId, - const EmberEUI64 destinationLongId, - EmberNodeId destinationShortId, - EmberMulticastId multicastId, - EmberAfClusterId clusterId, - EmberAfProfileId profileId, - uint16_t messageLength, - uint8_t* messageBytes); +EmberStatus emberAfSendInterPan(EmberPanId panId, const EmberEUI64 destinationLongId, EmberNodeId destinationShortId, + EmberMulticastId multicastId, EmberAfClusterId clusterId, EmberAfProfileId profileId, + uint16_t messageLength, uint8_t * messageBytes); /** * @brief Sends end device binding request. @@ -1540,8 +1409,7 @@ EmberStatus emberAfSendCommandMulticastWithAlias(EmberMulticastId multicastId, E /** * @brief emberAfSendCommandMulticast with attached message sent callback. */ -EmberStatus emberAfSendCommandMulticastWithCallback(EmberMulticastId multicastId, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendCommandMulticastWithCallback(EmberMulticastId multicastId, EmberAfMessageSentFunction callback); /** * @brief Sends the command prepared with emberAfFill.... macro. @@ -1561,14 +1429,12 @@ EmberStatus emberAfSendCommandMulticastToBindings(void); * using the emberAfFill... macros from the client command API. * It will be sent as unicast. */ -EmberStatus emberAfSendCommandUnicast(EmberOutgoingMessageType type, - uint16_t indexOrDestination); +EmberStatus emberAfSendCommandUnicast(EmberOutgoingMessageType type, uint16_t indexOrDestination); /** * @brief emberAfSendCommandUnicast with attached message sent callback. */ -EmberStatus emberAfSendCommandUnicastWithCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, +EmberStatus emberAfSendCommandUnicastWithCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberAfMessageSentFunction callback); /** @@ -1582,15 +1448,12 @@ EmberStatus emberAfSendCommandBroadcast(EmberNodeId destination); /** * @brief emberAfSendCommandBroadcast with attached message sent callback. */ -EmberStatus emberAfSendCommandBroadcastWithCallback(EmberNodeId destination, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendCommandBroadcastWithCallback(EmberNodeId destination, EmberAfMessageSentFunction callback); /** * @brief emberAfSendCommandBroadcast from alias with attached message sent callback. */ -EmberStatus emberAfSendCommandBroadcastWithAliasWithCallback(EmberNodeId destination, - EmberNodeId alias, - uint8_t sequence, +EmberStatus emberAfSendCommandBroadcastWithAliasWithCallback(EmberNodeId destination, EmberNodeId alias, uint8_t sequence, EmberAfMessageSentFunction callback); /** @@ -1599,9 +1462,7 @@ EmberStatus emberAfSendCommandBroadcastWithAliasWithCallback(EmberNodeId destina * This function is used to send a command that was previously prepared * using the emberAfFill... macros from the client command API. */ -EmberStatus emberAfSendCommandBroadcastWithAlias(EmberNodeId destination, - EmberNodeId alias, - uint8_t sequence); +EmberStatus emberAfSendCommandBroadcastWithAlias(EmberNodeId destination, EmberNodeId alias, uint8_t sequence); /** * @brief Sends the command prepared with emberAfFill.... macro. * @@ -1612,11 +1473,8 @@ EmberStatus emberAfSendCommandBroadcastWithAlias(EmberNodeId destination, * message will be sent to destinationShortId using short address mode. IF * multicastId is not zero, the message will be sent using multicast mode. */ -EmberStatus emberAfSendCommandInterPan(EmberPanId panId, - const EmberEUI64 destinationLongId, - EmberNodeId destinationShortId, - EmberMulticastId multicastId, - EmberAfProfileId profileId); +EmberStatus emberAfSendCommandInterPan(EmberPanId panId, const EmberEUI64 destinationLongId, EmberNodeId destinationShortId, + EmberMulticastId multicastId, EmberAfProfileId profileId); /** * @brief Sends a default response to a cluster command. @@ -1629,14 +1487,12 @@ EmberStatus emberAfSendCommandInterPan(EmberPanId panId, * @return An ::EmberStatus value that indicates the success or failure of * sending the response. */ -EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand *cmd, - EmberAfStatus status); +EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand * cmd, EmberAfStatus status); /** * @brief emberAfSendDefaultResponse with attached message sent callback. */ -EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand *cmd, - EmberAfStatus status, +EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand * cmd, EmberAfStatus status, EmberAfMessageSentFunction callback); /** @@ -1655,8 +1511,7 @@ EmberStatus emberAfSendImmediateDefaultResponse(EmberAfStatus status); /** * @brief emberAfSendImmediateDefaultResponse with attached message sent callback. */ -EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, - EmberAfMessageSentFunction callback); +EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, EmberAfMessageSentFunction callback); /** * @brief Returns the maximum size of the payload that the Application @@ -1674,14 +1529,12 @@ EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status * @param apsFrame The APS frame for the message. * @return The maximum APS payload length for the given message. */ -uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame); +uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame); /** * @brief Access to client API APS frame. */ -EmberApsFrame *emberAfGetCommandApsFrame(void); +EmberApsFrame * emberAfGetCommandApsFrame(void); /** * @brief Set the source and destination endpoints in the client API APS frame. @@ -1725,11 +1578,8 @@ void emberAfSetCommandEndpoints(uint8_t sourceEndpoint, uint8_t destinationEndpo * a match is discovered. (For broadcast discoveries, this is called once per * matching node, even if a node has multiple matching endpoints.) */ -EmberStatus emberAfFindDevicesByProfileAndCluster(EmberNodeId target, - EmberAfProfileId profileId, - EmberAfClusterId clusterId, - bool serverCluster, - EmberAfServiceDiscoveryCallback *callback); +EmberStatus emberAfFindDevicesByProfileAndCluster(EmberNodeId target, EmberAfProfileId profileId, EmberAfClusterId clusterId, + bool serverCluster, EmberAfServiceDiscoveryCallback * callback); /** * @brief Use this function to find all of the given in and out clusters @@ -1745,31 +1595,27 @@ EmberStatus emberAfFindDevicesByProfileAndCluster(EmberNodeId target, * @param callback Function pointer for the callback function triggered when * the discovery is returned. */ -EmberStatus emberAfFindClustersByDeviceAndEndpoint(EmberNodeId target, - uint8_t targetEndpoint, - EmberAfServiceDiscoveryCallback *callback); +EmberStatus emberAfFindClustersByDeviceAndEndpoint(EmberNodeId target, uint8_t targetEndpoint, + EmberAfServiceDiscoveryCallback * callback); /** * @brief Use this function to initiate a discovery for the IEEE address * of the specified node id. This will send a unicast sent to the target * node ID. */ -EmberStatus emberAfFindIeeeAddress(EmberNodeId shortAddress, - EmberAfServiceDiscoveryCallback *callback); +EmberStatus emberAfFindIeeeAddress(EmberNodeId shortAddress, EmberAfServiceDiscoveryCallback * callback); /** * @brief Use this function to initiate a discovery for the short ID of the * specified long address. This will send a broadcast to all * rx-on-when-idle devices (non-sleepies). */ -EmberStatus emberAfFindNodeId(EmberEUI64 longAddress, - EmberAfServiceDiscoveryCallback *callback); +EmberStatus emberAfFindNodeId(EmberEUI64 longAddress, EmberAfServiceDiscoveryCallback * callback); /** * @brief Initiate an Active Endpoint request ZDO message to the target node ID. */ -EmberStatus emberAfFindActiveEndpoints(EmberNodeId target, - EmberAfServiceDiscoveryCallback *callback); +EmberStatus emberAfFindActiveEndpoints(EmberNodeId target, EmberAfServiceDiscoveryCallback * callback); /** * @brief Use this function to add an entry for a remote device to the address @@ -1811,9 +1657,7 @@ uint8_t emberAfAddAddressTableEntry(EmberEUI64 longId, EmberNodeId shortId); * framework, or ::EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE if the index is out * of range. */ -EmberStatus emberAfSetAddressTableEntry(uint8_t index, - EmberEUI64 longId, - EmberNodeId shortId); +EmberStatus emberAfSetAddressTableEntry(uint8_t index, EmberEUI64 longId, EmberNodeId shortId); /** * @brief Use this function to remove a specific entry from the address table. @@ -1838,7 +1682,7 @@ EmberStatus emberAfRemoveAddressTableEntry(uint8_t index); * will be null. */ #define emberAfCurrentCommand() (emAfCurrentCommand) -extern EmberAfClusterCommand *emAfCurrentCommand; +extern EmberAfClusterCommand * emAfCurrentCommand; #endif /** @@ -1868,8 +1712,7 @@ EmberStatus emberAfInitiateKeyEstablishment(EmberNodeId nodeId, uint8_t endpoint * @param eui64 The EUI64 of the remote device. * @return ::EMBER_SUCCESS if key establishment was initiated successfully */ -EmberStatus emberAfInitiateInterPanKeyEstablishment(EmberPanId panId, - const EmberEUI64 eui64); +EmberStatus emberAfInitiateInterPanKeyEstablishment(EmberPanId panId, const EmberEUI64 eui64); /** @brief Use this function to tell if the device is in the process of * performing key establishment. @@ -1888,18 +1731,14 @@ bool emberAfPerformingKeyEstablishment(void); * @return ::EMBER_SUCCESS if the partner link key exchange was initiated * successfully. */ -EmberStatus emberAfInitiatePartnerLinkKeyExchange(EmberNodeId target, - uint8_t endpoint, - EmberAfPartnerLinkKeyExchangeCallback *callback); +EmberStatus emberAfInitiatePartnerLinkKeyExchange(EmberNodeId target, uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback * callback); #else - #define emberAfInitiateKeyEstablishment(nodeId, endpoint) \ - emberAfInitiateKeyEstablishmentCallback(nodeId, endpoint) - #define emberAfInitiateInterPanKeyEstablishment(panId, eui64) \ - emberAfInitiateInterPanKeyEstablishmentCallback(panId, eui64) - #define emberAfPerformingKeyEstablishment() \ - emberAfPerformingKeyEstablishmentCallback() - #define emberAfInitiatePartnerLinkKeyExchange(target, endpoint, callback) \ - emberAfInitiatePartnerLinkKeyExchangeCallback(target, endpoint, callback) +#define emberAfInitiateKeyEstablishment(nodeId, endpoint) emberAfInitiateKeyEstablishmentCallback(nodeId, endpoint) +#define emberAfInitiateInterPanKeyEstablishment(panId, eui64) emberAfInitiateInterPanKeyEstablishmentCallback(panId, eui64) +#define emberAfPerformingKeyEstablishment() emberAfPerformingKeyEstablishmentCallback() +#define emberAfInitiatePartnerLinkKeyExchange(target, endpoint, callback) \ + emberAfInitiatePartnerLinkKeyExchangeCallback(target, endpoint, callback) #endif /** @brief Use this function to determine if the security profile of the @@ -1915,18 +1754,18 @@ bool emberAfIsCurrentSecurityProfileSmartEnergy(void); // @{ // Frame control fields (8 bits total) // Bits 0 and 1 are Frame Type Sub-field -#define ZCL_FRAME_CONTROL_FRAME_TYPE_MASK (BIT(0) | BIT(1)) -#define ZCL_CLUSTER_SPECIFIC_COMMAND BIT(0) -#define ZCL_PROFILE_WIDE_COMMAND 0 -#define ZCL_GLOBAL_COMMAND (ZCL_PROFILE_WIDE_COMMAND) +#define ZCL_FRAME_CONTROL_FRAME_TYPE_MASK (BIT(0) | BIT(1)) +#define ZCL_CLUSTER_SPECIFIC_COMMAND BIT(0) +#define ZCL_PROFILE_WIDE_COMMAND 0 +#define ZCL_GLOBAL_COMMAND (ZCL_PROFILE_WIDE_COMMAND) // Bit 2 is Manufacturer Specific Sub-field -#define ZCL_MANUFACTURER_SPECIFIC_MASK BIT(2) +#define ZCL_MANUFACTURER_SPECIFIC_MASK BIT(2) // Bit 3 is Direction Sub-field -#define ZCL_FRAME_CONTROL_DIRECTION_MASK BIT(3) -#define ZCL_FRAME_CONTROL_SERVER_TO_CLIENT BIT(3) -#define ZCL_FRAME_CONTROL_CLIENT_TO_SERVER 0 +#define ZCL_FRAME_CONTROL_DIRECTION_MASK BIT(3) +#define ZCL_FRAME_CONTROL_SERVER_TO_CLIENT BIT(3) +#define ZCL_FRAME_CONTROL_CLIENT_TO_SERVER 0 // Bit 4 is Disable Default Response Sub-field -#define ZCL_DISABLE_DEFAULT_RESPONSE_MASK BIT(4) +#define ZCL_DISABLE_DEFAULT_RESPONSE_MASK BIT(4) // Bits 5 to 7 are reserved #define ZCL_DIRECTION_CLIENT_TO_SERVER 0 @@ -1936,13 +1775,13 @@ bool emberAfIsCurrentSecurityProfileSmartEnergy(void); // Frame Control (1-byte) // Sequence Number (1-byte) // Command Id (1-byte) -#define EMBER_AF_ZCL_OVERHEAD 3 +#define EMBER_AF_ZCL_OVERHEAD 3 #define EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD 5 // Permitted values for emberAfSetFormAndJoinMode -#define FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ BIT(0) -#define FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ BIT(1) -#define FIND_AND_JOIN_MODE_ALLOW_BOTH (FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ | FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ) +#define FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ BIT(0) +#define FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ BIT(1) +#define FIND_AND_JOIN_MODE_ALLOW_BOTH (FIND_AND_JOIN_MODE_ALLOW_2_4_GHZ | FIND_AND_JOIN_MODE_ALLOW_SUB_GHZ) /** @} END ZCL macros */ @@ -1956,7 +1795,7 @@ bool emberAfIsCurrentSecurityProfileSmartEnergy(void); * @return An ::EmberStatus value that indicates either the successful formation * of the new network or the reason that the network formation failed. */ -EmberStatus emberAfFormNetwork(EmberNetworkParameters *parameters); +EmberStatus emberAfFormNetwork(EmberNetworkParameters * parameters); /** @brief Use this function to associate with the network using the specified * network parameters. @@ -1966,7 +1805,7 @@ EmberStatus emberAfFormNetwork(EmberNetworkParameters *parameters); * @return An ::EmberStatus value that indicates either that the association * process began successfully or the reason for failure. */ -EmberStatus emberAfJoinNetwork(EmberNetworkParameters *parameters); +EmberStatus emberAfJoinNetwork(EmberNetworkParameters * parameters); #ifdef DOXYGEN_SHOULD_SKIP_THIS /** @brief Use this function to find an unused PAN id and form a new network. @@ -1982,8 +1821,8 @@ EmberStatus emberAfFindUnusedPanIdAndForm(void); */ EmberStatus emberAfStartSearchForJoinableNetwork(void); #else - #define emberAfFindUnusedPanIdAndForm() emberAfFindUnusedPanIdAndFormCallback() - #define emberAfStartSearchForJoinableNetwork() emberAfStartSearchForJoinableNetworkCallback() +#define emberAfFindUnusedPanIdAndForm() emberAfFindUnusedPanIdAndFormCallback() +#define emberAfStartSearchForJoinableNetwork() emberAfStartSearchForJoinableNetworkCallback() #endif /** @brief Sets the current network to that of the given index and adds it to @@ -2046,11 +1885,11 @@ int emberAfMain(MAIN_FUNCTION_PARAMETERS); /** @} END addtogroup */ #if !defined(DOXYGEN_SHOULD_SKIP_THIS) - #if defined(EMBER_TEST) - #define EMBER_TEST_ASSERT(x) assert(x) - #else - #define EMBER_TEST_ASSERT(x) - #endif +#if defined(EMBER_TEST) +#define EMBER_TEST_ASSERT(x) assert(x) +#else +#define EMBER_TEST_ASSERT(x) +#endif #endif /** @brief The maximum power level that can be used by the chip. diff --git a/examples/wifi-echo/server/esp32/main/attribute-size.c b/examples/wifi-echo/server/esp32/main/attribute-size.c index 14982a55bf4d29..19ddbc3a2f8480 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-size.c +++ b/examples/wifi-echo/server/esp32/main/attribute-size.c @@ -31,58 +31,67 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief Contains storage and function for retrieving attribute size. + * @brief Contains storage and function for retrieving + *attribute size. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ //#include PLATFORM_HEADER #include "af.h" -static const uint8_t attributeSizes[] = -{ +static const uint8_t attributeSizes[] = { #include "gen/attribute-size.h" }; uint8_t emberAfGetDataSize(uint8_t dataType) { - uint8_t i; - for (i = 0; (i + 1) < sizeof(attributeSizes); i += 2) { - if (attributeSizes[i] == dataType) { - return attributeSizes[i + 1]; + uint8_t i; + for (i = 0; (i + 1) < sizeof(attributeSizes); i += 2) + { + if (attributeSizes[i] == dataType) + { + return attributeSizes[i + 1]; + } } - } - return 0; + return 0; } -uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, - const uint8_t *buffer) +uint16_t emberAfAttributeValueSize(EmberAfAttributeType dataType, const uint8_t * buffer) { - // If the dataType is a string or long string, refer to the buffer for the - // string's length prefix; size is string length plus number of prefix bytes. - // If non-string, determine size from dataType. If dataType is unrecognized, - // return zero. - // - // Note: A non-empty long string has max length 0xFFFE, and adding 2 for its - // length prefix would roll a uint16_t back to zero. Choosing not to - // expand return type to uint32_t just to accommodate that one case. - uint16_t dataSize = 0; - if (emberAfIsThisDataTypeAStringType(dataType)) { - if (buffer != 0) { - if (emberAfIsStringAttributeType(dataType)) { - // size is string length plus 1-byte length prefix - dataSize = ((uint16_t) emberAfStringLength(buffer)) + 1u; - } else { - // size is long string length plus 2-byte length prefix - dataSize = emberAfLongStringLength(buffer) + 2u; - } + // If the dataType is a string or long string, refer to the buffer for the + // string's length prefix; size is string length plus number of prefix bytes. + // If non-string, determine size from dataType. If dataType is unrecognized, + // return zero. + // + // Note: A non-empty long string has max length 0xFFFE, and adding 2 for its + // length prefix would roll a uint16_t back to zero. Choosing not to + // expand return type to uint32_t just to accommodate that one case. + uint16_t dataSize = 0; + if (emberAfIsThisDataTypeAStringType(dataType)) + { + if (buffer != 0) + { + if (emberAfIsStringAttributeType(dataType)) + { + // size is string length plus 1-byte length prefix + dataSize = ((uint16_t) emberAfStringLength(buffer)) + 1u; + } + else + { + // size is long string length plus 2-byte length prefix + dataSize = emberAfLongStringLength(buffer) + 2u; + } + } + } + else + { + dataSize = (uint16_t) emberAfGetDataSize(dataType); } - } else { - dataSize = (uint16_t) emberAfGetDataSize(dataType); - } - return dataSize; + return dataSize; } diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.c b/examples/wifi-echo/server/esp32/main/attribute-storage.c index ada4cabc8b7a76..a932931db40534 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-storage.c +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.c @@ -31,14 +31,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief Contains the per-endpoint configuration of attribute tables. + * @brief Contains the per-endpoint configuration of + *attribute tables. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ -#include "af.h" #include "attribute-storage.h" +#include "af.h" #include "common.h" #include "gen/znet-bookkeeping.h" @@ -57,8 +59,7 @@ EmberAfDefinedEndpoint emAfEndpoints[MAX_ENDPOINT_COUNT]; uint8_t attributeData[ACTUAL_ATTRIBUTE_SIZE]; -#if (!defined(ATTRIBUTE_SINGLETONS_SIZE)) \ - || (ATTRIBUTE_SINGLETONS_SIZE == 0) +#if (!defined(ATTRIBUTE_SINGLETONS_SIZE)) || (ATTRIBUTE_SINGLETONS_SIZE == 0) #define ACTUAL_SINGLETONS_SIZE 1 #else #define ACTUAL_SINGLETONS_SIZE ATTRIBUTE_SINGLETONS_SIZE @@ -70,41 +71,41 @@ uint8_t emberEndpointCount = 0; // If we have attributes that are more than 2 bytes, then // we need this data block for the defaults #ifdef GENERATED_DEFAULTS -const uint8_t generatedDefaults[] = GENERATED_DEFAULTS; +const uint8_t generatedDefaults[] = GENERATED_DEFAULTS; #endif // GENERATED_DEFAULTS #ifdef GENERATED_MIN_MAX_DEFAULTS -const EmberAfAttributeMinMaxValue minMaxDefaults[] = GENERATED_MIN_MAX_DEFAULTS; -#endif //GENERATED_MIN_MAX_DEFAULTS +const EmberAfAttributeMinMaxValue minMaxDefaults[] = GENERATED_MIN_MAX_DEFAULTS; +#endif // GENERATED_MIN_MAX_DEFAULTS #ifdef GENERATED_FUNCTION_ARRAYS GENERATED_FUNCTION_ARRAYS #endif #ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY -const EmberAfCommandMetadata generatedCommands[] = GENERATED_COMMANDS; +const EmberAfCommandMetadata generatedCommands[] = GENERATED_COMMANDS; const EmberAfManufacturerCodeEntry commandManufacturerCodes[] = GENERATED_COMMAND_MANUFACTURER_CODES; -const uint16_t commandManufacturerCodeCount = GENERATED_COMMAND_MANUFACTURER_CODE_COUNT; +const uint16_t commandManufacturerCodeCount = GENERATED_COMMAND_MANUFACTURER_CODE_COUNT; #endif -const EmberAfAttributeMetadata generatedAttributes[] = GENERATED_ATTRIBUTES; -const EmberAfCluster generatedClusters[] = GENERATED_CLUSTERS; -const EmberAfEndpointType generatedEmberAfEndpointTypes[] = GENERATED_ENDPOINT_TYPES; -const EmAfZigbeeProNetwork emAfZigbeeProNetworks[] = EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS; +const EmberAfAttributeMetadata generatedAttributes[] = GENERATED_ATTRIBUTES; +const EmberAfCluster generatedClusters[] = GENERATED_CLUSTERS; +const EmberAfEndpointType generatedEmberAfEndpointTypes[] = GENERATED_ENDPOINT_TYPES; +const EmAfZigbeeProNetwork emAfZigbeeProNetworks[] = EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS; -const EmberAfManufacturerCodeEntry clusterManufacturerCodes[] = GENERATED_CLUSTER_MANUFACTURER_CODES; -const uint16_t clusterManufacturerCodeCount = GENERATED_CLUSTER_MANUFACTURER_CODE_COUNT; +const EmberAfManufacturerCodeEntry clusterManufacturerCodes[] = GENERATED_CLUSTER_MANUFACTURER_CODES; +const uint16_t clusterManufacturerCodeCount = GENERATED_CLUSTER_MANUFACTURER_CODE_COUNT; const EmberAfManufacturerCodeEntry attributeManufacturerCodes[] = GENERATED_ATTRIBUTE_MANUFACTURER_CODES; -const uint16_t attributeManufacturerCodeCount = GENERATED_ATTRIBUTE_MANUFACTURER_CODE_COUNT; +const uint16_t attributeManufacturerCodeCount = GENERATED_ATTRIBUTE_MANUFACTURER_CODE_COUNT; #if !defined(EMBER_SCRIPTED_TEST) -#define endpointNumber(x) fixedEndpoints[x] -#define endpointProfileId(x) fixedProfileIds[x] -#define endpointDeviceId(x) fixedDeviceIds[x] +#define endpointNumber(x) fixedEndpoints[x] +#define endpointProfileId(x) fixedProfileIds[x] +#define endpointDeviceId(x) fixedDeviceIds[x] #define endpointDeviceVersion(x) fixedDeviceVersions[x] // Added 'Macro' to silence MISRA warning about conflict with synonymous vars. -#define endpointTypeMacro(x) (EmberAfEndpointType*)&(generatedEmberAfEndpointTypes[fixedEmberAfEndpointTypes[x]]) -#define endpointNetworkIndex(x) fixedNetworks[x] +#define endpointTypeMacro(x) (EmberAfEndpointType *) &(generatedEmberAfEndpointTypes[fixedEmberAfEndpointTypes[x]]) +#define endpointNetworkIndex(x) fixedNetworks[x] #endif //------------------------------------------------------------------------------ @@ -118,371 +119,322 @@ static uint8_t findClusterEndpointIndex(uint8_t endpoint, EmberAfClusterId clust // Initial configuration void emberAfEndpointConfigure(void) { - uint8_t ep; + uint8_t ep; #if !defined(EMBER_SCRIPTED_TEST) - uint8_t fixedEndpoints[] = FIXED_ENDPOINT_ARRAY; - uint16_t fixedProfileIds[] = FIXED_PROFILE_IDS; - uint16_t fixedDeviceIds[] = FIXED_DEVICE_IDS; - uint8_t fixedDeviceVersions[] = FIXED_DEVICE_VERSIONS; - uint8_t fixedEmberAfEndpointTypes[] = FIXED_ENDPOINT_TYPES; - uint8_t fixedNetworks[] = FIXED_NETWORKS; + uint8_t fixedEndpoints[] = FIXED_ENDPOINT_ARRAY; + uint16_t fixedProfileIds[] = FIXED_PROFILE_IDS; + uint16_t fixedDeviceIds[] = FIXED_DEVICE_IDS; + uint8_t fixedDeviceVersions[] = FIXED_DEVICE_VERSIONS; + uint8_t fixedEmberAfEndpointTypes[] = FIXED_ENDPOINT_TYPES; + uint8_t fixedNetworks[] = FIXED_NETWORKS; #endif - emberEndpointCount = FIXED_ENDPOINT_COUNT; - for ( ep = 0; ep < FIXED_ENDPOINT_COUNT; ep++ ) { - emAfEndpoints[ep].endpoint = endpointNumber(ep); - emAfEndpoints[ep].profileId = endpointProfileId(ep); - emAfEndpoints[ep].deviceId = endpointDeviceId(ep); - emAfEndpoints[ep].deviceVersion = endpointDeviceVersion(ep); - emAfEndpoints[ep].endpointType = endpointTypeMacro(ep); - emAfEndpoints[ep].networkIndex = endpointNetworkIndex(ep); - emAfEndpoints[ep].bitmask = EMBER_AF_ENDPOINT_ENABLED; - } + emberEndpointCount = FIXED_ENDPOINT_COUNT; + for (ep = 0; ep < FIXED_ENDPOINT_COUNT; ep++) + { + emAfEndpoints[ep].endpoint = endpointNumber(ep); + emAfEndpoints[ep].profileId = endpointProfileId(ep); + emAfEndpoints[ep].deviceId = endpointDeviceId(ep); + emAfEndpoints[ep].deviceVersion = endpointDeviceVersion(ep); + emAfEndpoints[ep].endpointType = endpointTypeMacro(ep); + emAfEndpoints[ep].networkIndex = endpointNetworkIndex(ep); + emAfEndpoints[ep].bitmask = EMBER_AF_ENDPOINT_ENABLED; + } } void emberAfSetEndpointCount(uint8_t dynamicEndpointCount) { - emberEndpointCount = FIXED_ENDPOINT_COUNT + dynamicEndpointCount; + emberEndpointCount = FIXED_ENDPOINT_COUNT + dynamicEndpointCount; } uint8_t emberAfFixedEndpointCount(void) { - return FIXED_ENDPOINT_COUNT; + return FIXED_ENDPOINT_COUNT; } uint8_t emberAfEndpointCount(void) { - return emberEndpointCount; + return emberEndpointCount; } bool emberAfEndpointIndexIsEnabled(uint8_t index) { - return (emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED); + return (emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED); } // some data types (like strings) are sent OTA in human readable order // (how they are read) instead of little endian as the data types are. bool emberAfIsThisDataTypeAStringType(EmberAfAttributeType dataType) { - return (dataType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE - || dataType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE - || dataType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE - || dataType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); + return (dataType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE || dataType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE || + dataType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE || dataType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); } bool emberAfIsStringAttributeType(EmberAfAttributeType attributeType) { - return (attributeType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE - || attributeType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE); + return (attributeType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE || attributeType == ZCL_CHAR_STRING_ATTRIBUTE_TYPE); } bool emberAfIsLongStringAttributeType(EmberAfAttributeType attributeType) { - return (attributeType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE - || attributeType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); + return (attributeType == ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE || attributeType == ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE); } // This function is used to call the per-cluster default response callback -void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status, - uint8_t clientServerMask, - uint16_t manufacturerCode) -{ - EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, - clusterId, - clientServerMask, - manufacturerCode); - if (cluster != NULL) { - EmberAfGenericClusterFunction f = - emberAfFindClusterFunction(cluster, - CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION); - if (f != NULL) { - //emberAfPushEndpointNetworkIndex(endpoint); - ((EmberAfDefaultResponseFunction)f)(endpoint, commandId, status); - //emberAfPopNetworkIndex(); +void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t commandId, + EmberAfStatus status, uint8_t clientServerMask, uint16_t manufacturerCode) +{ + EmberAfCluster * cluster = emberAfFindClusterWithMfgCode(endpoint, clusterId, clientServerMask, manufacturerCode); + if (cluster != NULL) + { + EmberAfGenericClusterFunction f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION); + if (f != NULL) + { + // emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfDefaultResponseFunction) f)(endpoint, commandId, status); + // emberAfPopNetworkIndex(); + } } - } } // This function is used to call the per-cluster default response callback, and // wraps the emberAfClusterDefaultResponseWithMfgCodeCallback with a // EMBER_AF_NULL_MANUFACTURER_CODE. -void emberAfClusterDefaultResponseCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status, +void emberAfClusterDefaultResponseCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t commandId, EmberAfStatus status, uint8_t clientServerMask) { - emberAfClusterDefaultResponseWithMfgCodeCallback(endpoint, - clusterId, - commandId, - status, - clientServerMask, - EMBER_AF_NULL_MANUFACTURER_CODE); + emberAfClusterDefaultResponseWithMfgCodeCallback(endpoint, clusterId, commandId, status, clientServerMask, + EMBER_AF_NULL_MANUFACTURER_CODE); } // This function is used to call the per-cluster message sent callback -void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status, +void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status, uint16_t mfgCode) { - if (apsFrame != NULL && message != NULL && msgLen != 0) { - EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(apsFrame->sourceEndpoint, - apsFrame->clusterId, - (((message[0] - & ZCL_FRAME_CONTROL_DIRECTION_MASK) - == ZCL_FRAME_CONTROL_SERVER_TO_CLIENT) - ? CLUSTER_MASK_SERVER - : CLUSTER_MASK_CLIENT), - mfgCode); - if (cluster != NULL) { - EmberAfGenericClusterFunction f = - emberAfFindClusterFunction(cluster, - CLUSTER_MASK_MESSAGE_SENT_FUNCTION); - if (f != NULL) { - //emberAfPushEndpointNetworkIndex(apsFrame->sourceEndpoint); - ((EmberAfMessageSentFunction)f)(type, - indexOrDestination, - apsFrame, - msgLen, - message, - status); - //emberAfPopNetworkIndex(); - } + if (apsFrame != NULL && message != NULL && msgLen != 0) + { + EmberAfCluster * cluster = emberAfFindClusterWithMfgCode( + apsFrame->sourceEndpoint, apsFrame->clusterId, + (((message[0] & ZCL_FRAME_CONTROL_DIRECTION_MASK) == ZCL_FRAME_CONTROL_SERVER_TO_CLIENT) ? CLUSTER_MASK_SERVER + : CLUSTER_MASK_CLIENT), + mfgCode); + if (cluster != NULL) + { + EmberAfGenericClusterFunction f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_MESSAGE_SENT_FUNCTION); + if (f != NULL) + { + // emberAfPushEndpointNetworkIndex(apsFrame->sourceEndpoint); + ((EmberAfMessageSentFunction) f)(type, indexOrDestination, apsFrame, msgLen, message, status); + // emberAfPopNetworkIndex(); + } + } } - } } // This function is used to call the per-cluster message sent callback, and // wraps the emberAfClusterMessageSentWithMfgCodeCallback with a // EMBER_AF_NULL_MANUFACTURER_CODE. -void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status) -{ - emberAfClusterMessageSentWithMfgCodeCallback(type, - indexOrDestination, - apsFrame, - msgLen, - message, - status, - EMBER_AF_NULL_MANUFACTURER_CODE); +void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status) +{ + emberAfClusterMessageSentWithMfgCodeCallback(type, indexOrDestination, apsFrame, msgLen, message, status, + EMBER_AF_NULL_MANUFACTURER_CODE); } // This function is used to call the per-cluster attribute changed callback -void emAfClusterAttributeChangedCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t clientServerMask, - uint16_t manufacturerCode) -{ - EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, - clusterId, - clientServerMask, - manufacturerCode); - if (cluster != NULL) { - if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) { - EmberAfGenericClusterFunction f = - emberAfFindClusterFunction(cluster, - CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION); - if (f != NULL) { - //emberAfPushEndpointNetworkIndex(endpoint); - ((EmberAfClusterAttributeChangedCallback)f)(endpoint, attributeId); - //emberAfPopNetworkIndex(); - } - } else { - EmberAfGenericClusterFunction f = - emberAfFindClusterFunction(cluster, - CLUSTER_MASK_MANUFACTURER_SPECIFIC_ATTRIBUTE_CHANGED_FUNCTION); - if (f != NULL) { - //emberAfPushEndpointNetworkIndex(endpoint); - ((EmberAfManufacturerSpecificClusterAttributeChangedCallback)f)(endpoint, - attributeId, - manufacturerCode); - //emberAfPopNetworkIndex(); - } +void emAfClusterAttributeChangedCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t clientServerMask, uint16_t manufacturerCode) +{ + EmberAfCluster * cluster = emberAfFindClusterWithMfgCode(endpoint, clusterId, clientServerMask, manufacturerCode); + if (cluster != NULL) + { + if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) + { + EmberAfGenericClusterFunction f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) + { + // emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfClusterAttributeChangedCallback) f)(endpoint, attributeId); + // emberAfPopNetworkIndex(); + } + } + else + { + EmberAfGenericClusterFunction f = + emberAfFindClusterFunction(cluster, CLUSTER_MASK_MANUFACTURER_SPECIFIC_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) + { + // emberAfPushEndpointNetworkIndex(endpoint); + ((EmberAfManufacturerSpecificClusterAttributeChangedCallback) f)(endpoint, attributeId, manufacturerCode); + // emberAfPopNetworkIndex(); + } + } } - } } // This function is used to call the per-cluster pre-attribute changed callback -EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t clientServerMask, - uint16_t manufacturerCode, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t* value) -{ - EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, - clusterId, - clientServerMask, - manufacturerCode); - if (cluster == NULL) { - return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; - } else { - EmberAfStatus status = EMBER_ZCL_STATUS_SUCCESS; - if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) { - EmberAfGenericClusterFunction f = - emberAfFindClusterFunction(cluster, - CLUSTER_MASK_PRE_ATTRIBUTE_CHANGED_FUNCTION); - if (f != NULL) { - //emberAfPushEndpointNetworkIndex(endpoint); - status = ((EmberAfClusterPreAttributeChangedCallback)f)(endpoint, - attributeId, - attributeType, - size, - value); - //emberAfPopNetworkIndex(); - } +EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t clientServerMask, uint16_t manufacturerCode, + EmberAfAttributeType attributeType, uint8_t size, uint8_t * value) +{ + EmberAfCluster * cluster = emberAfFindClusterWithMfgCode(endpoint, clusterId, clientServerMask, manufacturerCode); + if (cluster == NULL) + { + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; } - return status; - } -} - -static void initializeEndpoint(EmberAfDefinedEndpoint* definedEndpoint) -{ - uint8_t clusterIndex; - EmberAfEndpointType* epType = definedEndpoint->endpointType; - //emberAfPushEndpointNetworkIndex(definedEndpoint->endpoint); - for ( clusterIndex = 0; - clusterIndex < epType->clusterCount; - clusterIndex++ ) { - EmberAfCluster *cluster = &(epType->cluster[clusterIndex]); - EmberAfGenericClusterFunction f; - emberAfClusterInitCallback(definedEndpoint->endpoint, cluster->clusterId); - f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_INIT_FUNCTION); - if ( f != NULL ) { - ((EmberAfInitFunction)f)(definedEndpoint->endpoint); + else + { + EmberAfStatus status = EMBER_ZCL_STATUS_SUCCESS; + if (manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE) + { + EmberAfGenericClusterFunction f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_PRE_ATTRIBUTE_CHANGED_FUNCTION); + if (f != NULL) + { + // emberAfPushEndpointNetworkIndex(endpoint); + status = ((EmberAfClusterPreAttributeChangedCallback) f)(endpoint, attributeId, attributeType, size, value); + // emberAfPopNetworkIndex(); + } + } + return status; } - } - //emberAfPopNetworkIndex(); +} + +static void initializeEndpoint(EmberAfDefinedEndpoint * definedEndpoint) +{ + uint8_t clusterIndex; + EmberAfEndpointType * epType = definedEndpoint->endpointType; + // emberAfPushEndpointNetworkIndex(definedEndpoint->endpoint); + for (clusterIndex = 0; clusterIndex < epType->clusterCount; clusterIndex++) + { + EmberAfCluster * cluster = &(epType->cluster[clusterIndex]); + EmberAfGenericClusterFunction f; + emberAfClusterInitCallback(definedEndpoint->endpoint, cluster->clusterId); + f = emberAfFindClusterFunction(cluster, CLUSTER_MASK_INIT_FUNCTION); + if (f != NULL) + { + ((EmberAfInitFunction) f)(definedEndpoint->endpoint); + } + } + // emberAfPopNetworkIndex(); } // Calls the init functions. void emAfCallInits(void) { - uint8_t index; - for ( index = 0; index < emberAfEndpointCount(); index++ ) { - if (emberAfEndpointIndexIsEnabled(index)) { - initializeEndpoint(&(emAfEndpoints[index])); + uint8_t index; + for (index = 0; index < emberAfEndpointCount(); index++) + { + if (emberAfEndpointIndexIsEnabled(index)) + { + initializeEndpoint(&(emAfEndpoints[index])); + } } - } } // Returns the pointer to metadata, or null if it is not found -EmberAfAttributeMetadata *emberAfLocateAttributeMetadata(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode) -{ - EmberAfAttributeMetadata *metadata = NULL; - EmberAfAttributeSearchRecord record; - record.endpoint = endpoint; - record.clusterId = clusterId; - record.clusterMask = mask; - record.attributeId = attributeId; - record.manufacturerCode = manufacturerCode; - emAfReadOrWriteAttribute(&record, - &metadata, - NULL, // buffer - 0, // buffer size - false); // write? - return metadata; -} - -static uint8_t* singletonAttributeLocation(EmberAfAttributeMetadata *am) -{ - EmberAfAttributeMetadata *m = (EmberAfAttributeMetadata *)&(generatedAttributes[0]); - uint16_t index = 0; - while ( m < am ) { - if ((m->mask & ATTRIBUTE_MASK_SINGLETON) != 0U) { - index += m->size; +EmberAfAttributeMetadata * emberAfLocateAttributeMetadata(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode) +{ + EmberAfAttributeMetadata * metadata = NULL; + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = clusterId; + record.clusterMask = mask; + record.attributeId = attributeId; + record.manufacturerCode = manufacturerCode; + emAfReadOrWriteAttribute(&record, &metadata, + NULL, // buffer + 0, // buffer size + false); // write? + return metadata; +} + +static uint8_t * singletonAttributeLocation(EmberAfAttributeMetadata * am) +{ + EmberAfAttributeMetadata * m = (EmberAfAttributeMetadata *) &(generatedAttributes[0]); + uint16_t index = 0; + while (m < am) + { + if ((m->mask & ATTRIBUTE_MASK_SINGLETON) != 0U) + { + index += m->size; + } + m++; } - m++; - } - return (uint8_t *)(singletonAttributeData + index); + return (uint8_t *) (singletonAttributeData + index); } // This function does mem copy, but smartly, which means that if the type is a // string, it will copy as much as it can. // If src == NULL, then this method will set memory to zeroes -static EmberAfStatus typeSensitiveMemCopy(uint8_t* dest, - uint8_t* src, - EmberAfAttributeMetadata * am, - bool write, +static EmberAfStatus typeSensitiveMemCopy(uint8_t * dest, uint8_t * src, EmberAfAttributeMetadata * am, bool write, uint16_t readLength) { - EmberAfAttributeType attributeType = am->attributeType; - uint16_t size = (readLength == 0) ? am->size : readLength; + EmberAfAttributeType attributeType = am->attributeType; + uint16_t size = (readLength == 0) ? am->size : readLength; - if (emberAfIsStringAttributeType(attributeType)) { - emberAfCopyString(dest, src, size - 1); - } else if (emberAfIsLongStringAttributeType(attributeType)) { - emberAfCopyLongString(dest, src, size - 2); - } else { - if (!write && readLength != 0 && readLength < am->size) { - return EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; + if (emberAfIsStringAttributeType(attributeType)) + { + emberAfCopyString(dest, src, size - 1); } - if ( src == NULL ) { - MEMSET(dest, 0, size); - } else { - MEMMOVE(dest, src, size); + else if (emberAfIsLongStringAttributeType(attributeType)) + { + emberAfCopyLongString(dest, src, size - 2); } - } - return EMBER_ZCL_STATUS_SUCCESS; + else + { + if (!write && readLength != 0 && readLength < am->size) + { + return EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; + } + if (src == NULL) + { + MEMSET(dest, 0, size); + } + else + { + MEMMOVE(dest, src, size); + } + } + return EMBER_ZCL_STATUS_SUCCESS; } // Returns the manufacturer code or ::EMBER_AF_NULL_MANUFACTURER_CODE if none // could be found. -static uint16_t getManufacturerCode(EmberAfManufacturerCodeEntry *codes, - uint16_t codeTableSize, - uint16_t tableIndex) -{ - uint16_t i; - for (i = 0; i < codeTableSize; i++) { - if (codes->index == tableIndex) { - return codes->manufacturerCode; +static uint16_t getManufacturerCode(EmberAfManufacturerCodeEntry * codes, uint16_t codeTableSize, uint16_t tableIndex) +{ + uint16_t i; + for (i = 0; i < codeTableSize; i++) + { + if (codes->index == tableIndex) + { + return codes->manufacturerCode; + } + codes++; } - codes++; - } - return EMBER_AF_NULL_MANUFACTURER_CODE; + return EMBER_AF_NULL_MANUFACTURER_CODE; } // This function basically wraps getManufacturerCode with the parameters // associating an attributes metadata with its code. -uint16_t emberAfGetMfgCode(EmberAfAttributeMetadata *metadata) +uint16_t emberAfGetMfgCode(EmberAfAttributeMetadata * metadata) { - return getManufacturerCode((EmberAfManufacturerCodeEntry *) attributeManufacturerCodes, - attributeManufacturerCodeCount, - (metadata - generatedAttributes)); + return getManufacturerCode((EmberAfManufacturerCodeEntry *) attributeManufacturerCodes, attributeManufacturerCodeCount, + (metadata - generatedAttributes)); } -uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster *cluster, - EmberAfAttributeMetadata *attMetaData) +uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster * cluster, EmberAfAttributeMetadata * attMetaData) { - return (emberAfClusterIsManufacturerSpecific(cluster) - ? emAfGetManufacturerCodeForCluster(cluster) - : emberAfGetMfgCode(attMetaData)); + return (emberAfClusterIsManufacturerSpecific(cluster) ? emAfGetManufacturerCodeForCluster(cluster) + : emberAfGetMfgCode(attMetaData)); } -uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster *cluster) +uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster * cluster) { - return getManufacturerCode((EmberAfManufacturerCodeEntry *)clusterManufacturerCodes, - clusterManufacturerCodeCount, - (cluster - generatedClusters)); + return getManufacturerCode((EmberAfManufacturerCodeEntry *) clusterManufacturerCodes, clusterManufacturerCodeCount, + (cluster - generatedClusters)); } /** @@ -496,14 +448,11 @@ uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster *cluster) * and attRecord->clusterMask AND * 3. If the clusters are mf specific, their mfg codes match. */ -bool emAfMatchCluster(EmberAfCluster *cluster, - EmberAfAttributeSearchRecord *attRecord) +bool emAfMatchCluster(EmberAfCluster * cluster, EmberAfAttributeSearchRecord * attRecord) { - return (cluster->clusterId == attRecord->clusterId - && cluster->mask & attRecord->clusterMask - && (!emberAfClusterIsManufacturerSpecific(cluster) - || (emAfGetManufacturerCodeForCluster(cluster) - == attRecord->manufacturerCode))); + return (cluster->clusterId == attRecord->clusterId && cluster->mask & attRecord->clusterMask && + (!emberAfClusterIsManufacturerSpecific(cluster) || + (emAfGetManufacturerCodeForCluster(cluster) == attRecord->manufacturerCode))); } /** @@ -521,14 +470,11 @@ bool emAfMatchCluster(EmberAfCluster *cluster, * b. both stored and saught attributes are NOT mf specific OR * c. stored att IS mf specific AND mfg codes match. */ -bool emAfMatchAttribute(EmberAfCluster *cluster, - EmberAfAttributeMetadata *am, - EmberAfAttributeSearchRecord *attRecord) +bool emAfMatchAttribute(EmberAfCluster * cluster, EmberAfAttributeMetadata * am, EmberAfAttributeSearchRecord * attRecord) { - return (am->attributeId == attRecord->attributeId - && (emberAfClusterIsManufacturerSpecific(cluster) - || (emAfGetManufacturerCodeForAttribute(cluster, am) - == attRecord->manufacturerCode))); + return (am->attributeId == attRecord->attributeId && + (emberAfClusterIsManufacturerSpecific(cluster) || + (emAfGetManufacturerCodeForAttribute(cluster, am) == attRecord->manufacturerCode))); } // When reading non-string attributes, this function returns an error when destination @@ -544,105 +490,105 @@ bool emAfMatchAttribute(EmberAfCluster *cluster, // type. For strings, the function will copy as many bytes as will fit in the // attribute. This means the resulting string may be truncated. The length // byte(s) in the resulting string will reflect any truncated. -EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord *attRecord, - EmberAfAttributeMetadata **metadata, - uint8_t *buffer, - uint16_t readLength, - bool write) -{ - uint8_t i; - uint16_t attributeOffsetIndex = 0; - - for (i = 0; i < emberAfEndpointCount(); i++) { - if (emAfEndpoints[i].endpoint == attRecord->endpoint) { - EmberAfEndpointType *endpointType = emAfEndpoints[i].endpointType; - uint8_t clusterIndex; - if (!emberAfEndpointIndexIsEnabled(i)) { - continue; - } - for (clusterIndex = 0; - clusterIndex < endpointType->clusterCount; - clusterIndex++) { - EmberAfCluster *cluster = &(endpointType->cluster[clusterIndex]); - if (emAfMatchCluster(cluster, attRecord)) { // Got the cluster - uint16_t attrIndex; - for (attrIndex = 0; - attrIndex < cluster->attributeCount; - attrIndex++) { - EmberAfAttributeMetadata *am = &(cluster->attributes[attrIndex]); - if (emAfMatchAttribute(cluster, - am, - attRecord)) { // Got the attribute - // If passed metadata location is not null, populate - if (metadata != NULL) { - *metadata = am; - } - - { - uint8_t *attributeLocation = (am->mask & ATTRIBUTE_MASK_SINGLETON - ? singletonAttributeLocation(am) - : attributeData + attributeOffsetIndex); - uint8_t *src, *dst; - if (write) { - src = buffer; - dst = attributeLocation; - if (!emberAfAttributeWriteAccessCallback(attRecord->endpoint, - attRecord->clusterId, - emAfGetManufacturerCodeForAttribute(cluster, am), - am->attributeId)) { - return EMBER_ZCL_STATUS_NOT_AUTHORIZED; - } - } else { - if (buffer == NULL) { - return EMBER_ZCL_STATUS_SUCCESS; - } - - src = attributeLocation; - dst = buffer; - if (!emberAfAttributeReadAccessCallback(attRecord->endpoint, - attRecord->clusterId, - emAfGetManufacturerCodeForAttribute(cluster, am), - am->attributeId)) { - return EMBER_ZCL_STATUS_NOT_AUTHORIZED; - } +EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord * attRecord, EmberAfAttributeMetadata ** metadata, + uint8_t * buffer, uint16_t readLength, bool write) +{ + uint8_t i; + uint16_t attributeOffsetIndex = 0; + + for (i = 0; i < emberAfEndpointCount(); i++) + { + if (emAfEndpoints[i].endpoint == attRecord->endpoint) + { + EmberAfEndpointType * endpointType = emAfEndpoints[i].endpointType; + uint8_t clusterIndex; + if (!emberAfEndpointIndexIsEnabled(i)) + { + continue; + } + for (clusterIndex = 0; clusterIndex < endpointType->clusterCount; clusterIndex++) + { + EmberAfCluster * cluster = &(endpointType->cluster[clusterIndex]); + if (emAfMatchCluster(cluster, attRecord)) + { // Got the cluster + uint16_t attrIndex; + for (attrIndex = 0; attrIndex < cluster->attributeCount; attrIndex++) + { + EmberAfAttributeMetadata * am = &(cluster->attributes[attrIndex]); + if (emAfMatchAttribute(cluster, am, attRecord)) + { // Got the attribute + // If passed metadata location is not null, populate + if (metadata != NULL) + { + *metadata = am; + } + + { + uint8_t * attributeLocation = + (am->mask & ATTRIBUTE_MASK_SINGLETON ? singletonAttributeLocation(am) + : attributeData + attributeOffsetIndex); + uint8_t *src, *dst; + if (write) + { + src = buffer; + dst = attributeLocation; + if (!emberAfAttributeWriteAccessCallback(attRecord->endpoint, attRecord->clusterId, + emAfGetManufacturerCodeForAttribute(cluster, am), + am->attributeId)) + { + return EMBER_ZCL_STATUS_NOT_AUTHORIZED; + } + } + else + { + if (buffer == NULL) + { + return EMBER_ZCL_STATUS_SUCCESS; + } + + src = attributeLocation; + dst = buffer; + if (!emberAfAttributeReadAccessCallback(attRecord->endpoint, attRecord->clusterId, + emAfGetManufacturerCodeForAttribute(cluster, am), + am->attributeId)) + { + return EMBER_ZCL_STATUS_NOT_AUTHORIZED; + } + } + + return (am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE + ? (write) ? emberAfExternalAttributeWriteCallback( + attRecord->endpoint, attRecord->clusterId, am, + emAfGetManufacturerCodeForAttribute(cluster, am), buffer) + : emberAfExternalAttributeReadCallback( + attRecord->endpoint, attRecord->clusterId, am, + emAfGetManufacturerCodeForAttribute(cluster, am), buffer, + emberAfAttributeSize(am)) + : typeSensitiveMemCopy(dst, src, am, write, readLength)); + } + } + else + { // Not the attribute we are looking for + // Increase the index if attribute is not externally stored + if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE) && !(am->mask & ATTRIBUTE_MASK_SINGLETON)) + { + attributeOffsetIndex += emberAfAttributeSize(am); + } + } + } + } + else + { // Not the cluster we are looking for + attributeOffsetIndex += cluster->clusterSize; } - - return (am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE - ? (write) - ? emberAfExternalAttributeWriteCallback(attRecord->endpoint, - attRecord->clusterId, - am, - emAfGetManufacturerCodeForAttribute(cluster, am), - buffer) - : emberAfExternalAttributeReadCallback(attRecord->endpoint, - attRecord->clusterId, - am, - emAfGetManufacturerCodeForAttribute(cluster, am), - buffer, - emberAfAttributeSize(am)) - : typeSensitiveMemCopy(dst, - src, - am, - write, - readLength)); - } - } else { // Not the attribute we are looking for - // Increase the index if attribute is not externally stored - if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE) - && !(am->mask & ATTRIBUTE_MASK_SINGLETON) ) { - attributeOffsetIndex += emberAfAttributeSize(am); - } } - } - } else { // Not the cluster we are looking for - attributeOffsetIndex += cluster->clusterSize; } - } - } else { // Not the endpoint we are looking for - attributeOffsetIndex += emAfEndpoints[i].endpointType->endpointSize; + else + { // Not the endpoint we are looking for + attributeOffsetIndex += emAfEndpoints[i].endpointType->endpointSize; + } } - } - return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; // Sorry, attribute was not found. + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; // Sorry, attribute was not found. } // Check if a cluster is implemented or not. If yes, the cluster is returned. @@ -652,324 +598,332 @@ EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord *attRecord, // mask = 0 -> find either client or server // mask = CLUSTER_MASK_CLIENT -> find client // mask = CLUSTER_MASK_SERVER -> find server -EmberAfCluster *emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType *endpointType, - EmberAfClusterId clusterId, - EmberAfClusterMask mask, - uint16_t manufacturerCode) -{ - uint8_t i; - for (i = 0; i < endpointType->clusterCount; i++) { - EmberAfCluster *cluster = &(endpointType->cluster[i]); - if (cluster->clusterId == clusterId - && (mask == 0 - || (mask == CLUSTER_MASK_CLIENT && emberAfClusterIsClient(cluster)) - || (mask == CLUSTER_MASK_SERVER && emberAfClusterIsServer(cluster))) - && (!emberAfClusterIsManufacturerSpecific(cluster) - || (emAfGetManufacturerCodeForCluster(cluster) - == manufacturerCode) - // For compatibility with older stack api, we ignore manufacturer code here - // if the manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE - || manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE)) { - return cluster; +EmberAfCluster * emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType * endpointType, EmberAfClusterId clusterId, + EmberAfClusterMask mask, uint16_t manufacturerCode) +{ + uint8_t i; + for (i = 0; i < endpointType->clusterCount; i++) + { + EmberAfCluster * cluster = &(endpointType->cluster[i]); + if (cluster->clusterId == clusterId && + (mask == 0 || (mask == CLUSTER_MASK_CLIENT && emberAfClusterIsClient(cluster)) || + (mask == CLUSTER_MASK_SERVER && emberAfClusterIsServer(cluster))) && + (!emberAfClusterIsManufacturerSpecific(cluster) || + (emAfGetManufacturerCodeForCluster(cluster) == manufacturerCode) + // For compatibility with older stack api, we ignore manufacturer code here + // if the manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE + || manufacturerCode == EMBER_AF_NULL_MANUFACTURER_CODE)) + { + return cluster; + } } - } - return NULL; + return NULL; } // This functions wraps emberAfFindClusterInTypeWithMfgCode with // a manufacturerCode of EMBER_AF_NULL_MANUFACTURER_CODE. -EmberAfCluster *emberAfFindClusterInType(EmberAfEndpointType *endpointType, - EmberAfClusterId clusterId, - EmberAfClusterMask mask) +EmberAfCluster * emberAfFindClusterInType(EmberAfEndpointType * endpointType, EmberAfClusterId clusterId, EmberAfClusterMask mask) { - return emberAfFindClusterInTypeWithMfgCode(endpointType, - clusterId, - mask, - EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterInTypeWithMfgCode(endpointType, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); } // This code is used during unit tests for clusters that do not involve manufacturer code. // Should this code be used in other locations, manufacturerCode should be added. -uint8_t emberAfClusterIndex(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask) -{ - uint8_t ep; - uint8_t index = 0xFF; - for ( ep = 0; ep < emberAfEndpointCount(); ep++ ) { - EmberAfEndpointType *endpointType = emAfEndpoints[ep].endpointType; - if ( emberAfFindClusterInTypeWithMfgCode(endpointType, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL ) { - index++; - if ( emAfEndpoints[ep].endpoint == endpoint ) { - return index; - } +uint8_t emberAfClusterIndex(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask) +{ + uint8_t ep; + uint8_t index = 0xFF; + for (ep = 0; ep < emberAfEndpointCount(); ep++) + { + EmberAfEndpointType * endpointType = emAfEndpoints[ep].endpointType; + if (emberAfFindClusterInTypeWithMfgCode(endpointType, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL) + { + index++; + if (emAfEndpoints[ep].endpoint == endpoint) + { + return index; + } + } } - } - return 0xFF; + return 0xFF; } // Returns true uf endpoint contains passed cluster bool emberAfContainsClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, manufacturerCode) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, manufacturerCode) != NULL); } // Returns true if endpoint contains passed cluster as a server bool emberAfContainsServerWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode) != NULL); } // Returns true if endpoint contains passed cluster as a client bool emberAfContainsClientWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode) != NULL); } // Wraps emberAfContainsClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE // This will find the first cluster that has the clusterId given, regardless of mfgCode. bool emberAfContainsCluster(uint8_t endpoint, EmberAfClusterId clusterId) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, 0, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); } // Wraps emberAfContainsServerWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE // This will find the first server that has the clusterId given, regardless of mfgCode. bool emberAfContainsServer(uint8_t endpoint, EmberAfClusterId clusterId) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); } // Wraps emberAfContainsClientWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE // This will find the first client that has the clusterId given, regardless of mfgCode. bool emberAfContainsClient(uint8_t endpoint, EmberAfClusterId clusterId) { - return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); + return (emberAfFindClusterWithMfgCode(endpoint, clusterId, CLUSTER_MASK_CLIENT, EMBER_AF_NULL_MANUFACTURER_CODE) != NULL); } // Finds the cluster that matches endpoint, clusterId, direction, and manufacturerCode. -EmberAfCluster *emberAfFindClusterWithMfgCode(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask, - uint16_t manufacturerCode) +EmberAfCluster * emberAfFindClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask, + uint16_t manufacturerCode) { - uint8_t ep = emberAfIndexFromEndpoint(endpoint); - if ( ep == 0xFF ) { - return NULL; - } else { - return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); - } + uint8_t ep = emberAfIndexFromEndpoint(endpoint); + if (ep == 0xFF) + { + return NULL; + } + else + { + return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); + } } // This function wraps emberAfFindClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE // and will ignore the manufacturerCode when trying to find clusters. // This will return the first cluster in the cluster table that matches the parameters given. -EmberAfCluster *emberAfFindCluster(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask) +EmberAfCluster * emberAfFindCluster(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask) { - return emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); } // Returns cluster within the endpoint; Does not ignore disabled endpoints -EmberAfCluster *emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask, - uint16_t manufacturerCode) +EmberAfCluster * emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfClusterMask mask, uint16_t manufacturerCode) { - uint8_t ep = emberAfIndexFromEndpointIncludingDisabledEndpoints(endpoint); - if (ep < MAX_ENDPOINT_COUNT) { - return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); - } - return NULL; + uint8_t ep = emberAfIndexFromEndpointIncludingDisabledEndpoints(endpoint); + if (ep < MAX_ENDPOINT_COUNT) + { + return emberAfFindClusterInTypeWithMfgCode(emAfEndpoints[ep].endpointType, clusterId, mask, manufacturerCode); + } + return NULL; } // Returns cluster within the endpoint; Does not ignore disabled endpoints // This will ignore manufacturerCode. -EmberAfCluster *emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask) +EmberAfCluster * emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask) { - return emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(endpoint, clusterId, mask, EMBER_AF_NULL_MANUFACTURER_CODE); } // Server wrapper for findClusterEndpointIndex. uint8_t emberAfFindClusterServerEndpointIndexWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) { - return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode); + return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_SERVER, manufacturerCode); } // Client wrapper for findClusterEndpointIndex. uint8_t emberAfFindClusterClientEndpointIndexWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode) { - return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode); + return findClusterEndpointIndex(endpoint, clusterId, CLUSTER_MASK_CLIENT, manufacturerCode); } // Server wrapper for findClusterEndpointIndex // This will ignore manufacturerCode, and return the index for the first server that matches on clusterId uint8_t emberAfFindClusterServerEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId) { - return emberAfFindClusterServerEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterServerEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); } // Client wrapper for findClusterEndpointIndex // This will ignore manufacturerCode, and return the index for the first client that matches on clusterId uint8_t emberAfFindClusterClientEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId) { - return emberAfFindClusterClientEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterClientEndpointIndexWithMfgCode(endpoint, clusterId, EMBER_AF_NULL_MANUFACTURER_CODE); } // Returns the endpoint index within a given cluster static uint8_t findClusterEndpointIndex(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t mask, uint16_t manufacturerCode) { - uint8_t i, epi = 0; + uint8_t i, epi = 0; - if (emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, manufacturerCode) == NULL) { - return 0xFF; - } + if (emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, manufacturerCode) == NULL) + { + return 0xFF; + } - for (i = 0; i < emberAfEndpointCount(); i++) { - if (emAfEndpoints[i].endpoint == endpoint) { - break; + for (i = 0; i < emberAfEndpointCount(); i++) + { + if (emAfEndpoints[i].endpoint == endpoint) + { + break; + } + epi += (emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(emAfEndpoints[i].endpoint, clusterId, mask, + manufacturerCode) != NULL) + ? 1 + : 0; } - epi += (emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(emAfEndpoints[i].endpoint, clusterId, mask, manufacturerCode) != NULL) ? 1 : 0; - } - return epi; + return epi; } static uint8_t findIndexFromEndpoint(uint8_t endpoint, bool ignoreDisabledEndpoints) { - uint8_t epi; - for (epi = 0; epi < emberAfEndpointCount(); epi++) { - if (emAfEndpoints[epi].endpoint == endpoint - && (!ignoreDisabledEndpoints - || emAfEndpoints[epi].bitmask & EMBER_AF_ENDPOINT_ENABLED)) { - return epi; + uint8_t epi; + for (epi = 0; epi < emberAfEndpointCount(); epi++) + { + if (emAfEndpoints[epi].endpoint == endpoint && + (!ignoreDisabledEndpoints || emAfEndpoints[epi].bitmask & EMBER_AF_ENDPOINT_ENABLED)) + { + return epi; + } } - } - return 0xFF; + return 0xFF; } bool emberAfEndpointIsEnabled(uint8_t endpoint) { - uint8_t index = findIndexFromEndpoint(endpoint, - false); // ignore disabled endpoints? + uint8_t index = findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? - EMBER_TEST_ASSERT(0xFF != index); + EMBER_TEST_ASSERT(0xFF != index); - if (0xFF == index) { - return false; - } + if (0xFF == index) + { + return false; + } - return emberAfEndpointIndexIsEnabled(index); + return emberAfEndpointIndexIsEnabled(index); } bool emberAfEndpointEnableDisable(uint8_t endpoint, bool enable) { - uint8_t index = findIndexFromEndpoint(endpoint, - false); // ignore disabled endpoints? - bool currentlyEnabled; + uint8_t index = findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? + bool currentlyEnabled; - if (0xFF == index) { - return false; - } + if (0xFF == index) + { + return false; + } - currentlyEnabled = emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED; + currentlyEnabled = emAfEndpoints[index].bitmask & EMBER_AF_ENDPOINT_ENABLED; - if (enable) { - emAfEndpoints[index].bitmask |= EMBER_AF_ENDPOINT_ENABLED; - } else { - emAfEndpoints[index].bitmask &= EMBER_AF_ENDPOINT_DISABLED; - } + if (enable) + { + emAfEndpoints[index].bitmask |= EMBER_AF_ENDPOINT_ENABLED; + } + else + { + emAfEndpoints[index].bitmask &= EMBER_AF_ENDPOINT_DISABLED; + } #if defined(EZSP_HOST) - ezspSetEndpointFlags(endpoint, - (enable - ? EZSP_ENDPOINT_ENABLED - : EZSP_ENDPOINT_DISABLED)); + ezspSetEndpointFlags(endpoint, (enable ? EZSP_ENDPOINT_ENABLED : EZSP_ENDPOINT_DISABLED)); #endif - if (currentlyEnabled != enable) { - if (enable) { - initializeEndpoint(&(emAfEndpoints[index])); - } else { - uint8_t i; - for (i = 0; i < emAfEndpoints[index].endpointType->clusterCount; i++) { - EmberAfCluster* cluster = &((emAfEndpoints[index].endpointType->cluster)[i]); -// emberAfCorePrintln("Disabling cluster tick for ep:%d, cluster:0x%2X, %p", -// endpoint, -// cluster->clusterId, -// ((cluster->mask & CLUSTER_MASK_CLIENT) -// ? "client" -// : "server")); -// emberAfCoreFlush(); - emberAfDeactivateClusterTick(endpoint, - cluster->clusterId, - (cluster->mask & CLUSTER_MASK_CLIENT - ? EMBER_AF_CLIENT_CLUSTER_TICK - : EMBER_AF_SERVER_CLUSTER_TICK)); - } + if (currentlyEnabled != enable) + { + if (enable) + { + initializeEndpoint(&(emAfEndpoints[index])); + } + else + { + uint8_t i; + for (i = 0; i < emAfEndpoints[index].endpointType->clusterCount; i++) + { + EmberAfCluster * cluster = &((emAfEndpoints[index].endpointType->cluster)[i]); + // emberAfCorePrintln("Disabling cluster tick for ep:%d, cluster:0x%2X, %p", + // endpoint, + // cluster->clusterId, + // ((cluster->mask & CLUSTER_MASK_CLIENT) + // ? "client" + // : "server")); + // emberAfCoreFlush(); + emberAfDeactivateClusterTick( + endpoint, cluster->clusterId, + (cluster->mask & CLUSTER_MASK_CLIENT ? EMBER_AF_CLIENT_CLUSTER_TICK : EMBER_AF_SERVER_CLUSTER_TICK)); + } + } } - } - return true; + return true; } // Returns the index of a given endpoint. Does not consider disabled endpoints. uint8_t emberAfIndexFromEndpoint(uint8_t endpoint) { - return findIndexFromEndpoint(endpoint, - true); // ignore disabled endpoints? + return findIndexFromEndpoint(endpoint, + true); // ignore disabled endpoints? } // Returns the index of a given endpoint. Considers disabled endpoints. uint8_t emberAfIndexFromEndpointIncludingDisabledEndpoints(uint8_t endpoint) { - return findIndexFromEndpoint(endpoint, - false); // ignore disabled endpoints? + return findIndexFromEndpoint(endpoint, + false); // ignore disabled endpoints? } uint8_t emberAfEndpointFromIndex(uint8_t index) { - return emAfEndpoints[index].endpoint; + return emAfEndpoints[index].endpoint; } // If server == true, returns the number of server clusters, // otherwise number of client clusters on this endpoint uint8_t emberAfClusterCount(uint8_t endpoint, bool server) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - uint8_t i, c = 0; - EmberAfDefinedEndpoint *de; - EmberAfCluster *cluster; - - if ( index == 0xFF ) { - return 0; - } - de = &(emAfEndpoints[index]); - if ( de->endpointType == NULL) { - return 0; - } - for ( i = 0; i < de->endpointType->clusterCount; i++ ) { - cluster = &(de->endpointType->cluster[i]); - if ( server && emberAfClusterIsServer(cluster) ) { - c++; + uint8_t index = emberAfIndexFromEndpoint(endpoint); + uint8_t i, c = 0; + EmberAfDefinedEndpoint * de; + EmberAfCluster * cluster; + + if (index == 0xFF) + { + return 0; } - if ( (!server) && emberAfClusterIsClient(cluster) ) { - c++; + de = &(emAfEndpoints[index]); + if (de->endpointType == NULL) + { + return 0; } - } - return c; + for (i = 0; i < de->endpointType->clusterCount; i++) + { + cluster = &(de->endpointType->cluster[i]); + if (server && emberAfClusterIsServer(cluster)) + { + c++; + } + if ((!server) && emberAfClusterIsClient(cluster)) + { + c++; + } + } + return c; } uint8_t emberAfGetClusterCountForEndpoint(uint8_t endpoint) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if ( index == 0xFF) { - return 0; - } - return emAfEndpoints[index].endpointType->clusterCount; + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return 0; + } + return emAfEndpoints[index].endpointType->clusterCount; } // Note the difference in implementation from emberAfGetNthCluster(). @@ -981,244 +935,268 @@ uint8_t emberAfGetClusterCountForEndpoint(uint8_t endpoint) // - Use emberAfGetClusterCountForEndpoint() with emberAfGetClusterByIndex() // // Don't mix them. -EmberAfCluster* emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex) +EmberAfCluster * emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex) { - uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); - EmberAfDefinedEndpoint* definedEndpoint; + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + EmberAfDefinedEndpoint * definedEndpoint; - if (endpointIndex == 0xFF) { - return NULL; - } - definedEndpoint = &(emAfEndpoints[endpointIndex]); + if (endpointIndex == 0xFF) + { + return NULL; + } + definedEndpoint = &(emAfEndpoints[endpointIndex]); - if (clusterIndex >= definedEndpoint->endpointType->clusterCount) { - return NULL; - } - return &(definedEndpoint->endpointType->cluster[clusterIndex]); + if (clusterIndex >= definedEndpoint->endpointType->clusterCount) + { + return NULL; + } + return &(definedEndpoint->endpointType->cluster[clusterIndex]); } EmberAfProfileId emberAfGetProfileIdForEndpoint(uint8_t endpoint) { - uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); - if (endpointIndex == 0xFF) { - return EMBER_AF_INVALID_PROFILE_ID; - } - return emAfEndpoints[endpointIndex].profileId; + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + if (endpointIndex == 0xFF) + { + return EMBER_AF_INVALID_PROFILE_ID; + } + return emAfEndpoints[endpointIndex].profileId; } uint16_t emberAfGetDeviceIdForEndpoint(uint8_t endpoint) { - uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); - if (endpointIndex == 0xFF) { - return EMBER_AF_INVALID_PROFILE_ID; - } - return emAfEndpoints[endpointIndex].deviceId; + uint8_t endpointIndex = emberAfIndexFromEndpoint(endpoint); + if (endpointIndex == 0xFF) + { + return EMBER_AF_INVALID_PROFILE_ID; + } + return emAfEndpoints[endpointIndex].deviceId; } // Returns the cluster of Nth server or client cluster, // depending on server toggle. -EmberAfCluster *emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server) +EmberAfCluster * emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - EmberAfDefinedEndpoint *de; - uint8_t i, c = 0; - EmberAfCluster *cluster; + uint8_t index = emberAfIndexFromEndpoint(endpoint); + EmberAfDefinedEndpoint * de; + uint8_t i, c = 0; + EmberAfCluster * cluster; - if ( index == 0xFF ) { - return NULL; - } - de = &(emAfEndpoints[index]); - - for ( i = 0; i < de->endpointType->clusterCount; i++ ) { - cluster = &(de->endpointType->cluster[i]); - - if ( (server && emberAfClusterIsServer(cluster) ) - || ( (!server) && emberAfClusterIsClient(cluster) ) ) { - if ( c == n ) { - return cluster; - } - c++; + if (index == 0xFF) + { + return NULL; + } + de = &(emAfEndpoints[index]); + + for (i = 0; i < de->endpointType->clusterCount; i++) + { + cluster = &(de->endpointType->cluster[i]); + + if ((server && emberAfClusterIsServer(cluster)) || ((!server) && emberAfClusterIsClient(cluster))) + { + if (c == n) + { + return cluster; + } + c++; + } } - } - return NULL; + return NULL; } // Returns number of clusters put into the passed cluster list // for the given endpoint and client/server polarity -uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId *clusterList, uint8_t listLen, bool server) -{ - uint8_t clusterCount = emberAfClusterCount(endpoint, server); - uint8_t i; - EmberAfCluster *cluster; - if (clusterCount > listLen) { - clusterCount = listLen; - } - for (i = 0; i < clusterCount; i++) { - cluster = emberAfGetNthCluster(endpoint, i, server); - clusterList[i] = (cluster == NULL ? 0xFFFF : cluster->clusterId); - } - return clusterCount; +uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId * clusterList, uint8_t listLen, bool server) +{ + uint8_t clusterCount = emberAfClusterCount(endpoint, server); + uint8_t i; + EmberAfCluster * cluster; + if (clusterCount > listLen) + { + clusterCount = listLen; + } + for (i = 0; i < clusterCount; i++) + { + cluster = emberAfGetNthCluster(endpoint, i, server); + clusterList[i] = (cluster == NULL ? 0xFFFF : cluster->clusterId); + } + return clusterCount; } void emberAfInitializeAttributes(uint8_t endpoint) { - emAfLoadAttributeDefaults(endpoint, false); + emAfLoadAttributeDefaults(endpoint, false); } void emberAfResetAttributes(uint8_t endpoint) { - emAfLoadAttributeDefaults(endpoint, true); - emAfResetAttributes(endpoint); + emAfLoadAttributeDefaults(endpoint, true); + emAfResetAttributes(endpoint); } void emAfLoadAttributeDefaults(uint8_t endpoint, bool writeTokens) { - uint8_t ep, clusterI, curNetwork = 0 /* emberGetCurrentNetwork() */; - uint16_t attr; - uint8_t *ptr; - uint8_t epCount = emberAfEndpointCount(); - - for ( ep = 0; ep < epCount; ep++ ) { - EmberAfDefinedEndpoint *de; - if (endpoint != EMBER_BROADCAST_ENDPOINT) { - ep = emberAfIndexFromEndpoint(endpoint); - if (ep == 0xFF) { - return; - } - } - de = &(emAfEndpoints[ep]); - - // Ensure that the endpoint is on the current network - if (endpoint == EMBER_BROADCAST_ENDPOINT - && de->networkIndex != curNetwork) { - continue; - } - for ( clusterI = 0; clusterI < de->endpointType->clusterCount; clusterI++) { - EmberAfCluster *cluster = &(de->endpointType->cluster[clusterI]); - - // when the attributeCount is high, the loop takes too long to run and a - // watchdog kicks in causing a reset. As a workaround, we'll - // conditionally manually reset the watchdog. 300 sounds like a good - // magic number for now. - if (cluster->attributeCount > 300) { - // halResetWatchdog(); - } - for ( attr = 0; attr < cluster->attributeCount; attr++) { - EmberAfAttributeMetadata *am = &(cluster->attributes[attr]); - if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE)) { - EmberAfAttributeSearchRecord record; - record.endpoint = de->endpoint; - record.clusterId = cluster->clusterId; - record.clusterMask = (emberAfAttributeIsClient(am) - ? CLUSTER_MASK_CLIENT - : CLUSTER_MASK_SERVER); - record.attributeId = am->attributeId; - record.manufacturerCode = emAfGetManufacturerCodeForAttribute(cluster, - am); - if ((am->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) { - if ( emberAfAttributeSize(am) <= 2 ) { - ptr = (uint8_t*)&(am->defaultValue.ptrToMinMaxValue->defaultValue.defaultValue); - } else { - ptr = (uint8_t*)am->defaultValue.ptrToMinMaxValue->defaultValue.ptrToDefaultValue; + uint8_t ep, clusterI, curNetwork = 0 /* emberGetCurrentNetwork() */; + uint16_t attr; + uint8_t * ptr; + uint8_t epCount = emberAfEndpointCount(); + + for (ep = 0; ep < epCount; ep++) + { + EmberAfDefinedEndpoint * de; + if (endpoint != EMBER_BROADCAST_ENDPOINT) + { + ep = emberAfIndexFromEndpoint(endpoint); + if (ep == 0xFF) + { + return; } - } else { - if ( emberAfAttributeSize(am) <= 2 ) { - ptr = (uint8_t*)&(am->defaultValue.defaultValue); - } else { - ptr = (uint8_t*)am->defaultValue.ptrToDefaultValue; + } + de = &(emAfEndpoints[ep]); + + // Ensure that the endpoint is on the current network + if (endpoint == EMBER_BROADCAST_ENDPOINT && de->networkIndex != curNetwork) + { + continue; + } + for (clusterI = 0; clusterI < de->endpointType->clusterCount; clusterI++) + { + EmberAfCluster * cluster = &(de->endpointType->cluster[clusterI]); + + // when the attributeCount is high, the loop takes too long to run and a + // watchdog kicks in causing a reset. As a workaround, we'll + // conditionally manually reset the watchdog. 300 sounds like a good + // magic number for now. + if (cluster->attributeCount > 300) + { + // halResetWatchdog(); } - } - // At this point, ptr either points to a default value, or is NULL, in which case - // it should be treated as if it is pointing to an array of all zeroes. + for (attr = 0; attr < cluster->attributeCount; attr++) + { + EmberAfAttributeMetadata * am = &(cluster->attributes[attr]); + if (!(am->mask & ATTRIBUTE_MASK_EXTERNAL_STORAGE)) + { + EmberAfAttributeSearchRecord record; + record.endpoint = de->endpoint; + record.clusterId = cluster->clusterId; + record.clusterMask = (emberAfAttributeIsClient(am) ? CLUSTER_MASK_CLIENT : CLUSTER_MASK_SERVER); + record.attributeId = am->attributeId; + record.manufacturerCode = emAfGetManufacturerCodeForAttribute(cluster, am); + if ((am->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) + { + if (emberAfAttributeSize(am) <= 2) + { + ptr = (uint8_t *) &(am->defaultValue.ptrToMinMaxValue->defaultValue.defaultValue); + } + else + { + ptr = (uint8_t *) am->defaultValue.ptrToMinMaxValue->defaultValue.ptrToDefaultValue; + } + } + else + { + if (emberAfAttributeSize(am) <= 2) + { + ptr = (uint8_t *) &(am->defaultValue.defaultValue); + } + else + { + ptr = (uint8_t *) am->defaultValue.ptrToDefaultValue; + } + } + // At this point, ptr either points to a default value, or is NULL, in which case + // it should be treated as if it is pointing to an array of all zeroes. #if (BIGENDIAN_CPU) - // The default value for one- and two-byte attributes is stored in an - // uint16_t. On big-endian platforms, a pointer to the default value of - // a one-byte attribute will point to the wrong byte. So, for those - // cases, nudge the pointer forward so it points to the correct byte. - if (emberAfAttributeSize(am) == 1 && ptr != NULL) { - *ptr++; - } -#endif //BIGENDIAN - emAfReadOrWriteAttribute(&record, - NULL, // metadata - unused - ptr, - 0, // buffer size - unused - true); // write? - if (writeTokens) { - emAfSaveAttributeToToken(ptr, de->endpoint, record.clusterId, am); - } + // The default value for one- and two-byte attributes is stored in an + // uint16_t. On big-endian platforms, a pointer to the default value of + // a one-byte attribute will point to the wrong byte. So, for those + // cases, nudge the pointer forward so it points to the correct byte. + if (emberAfAttributeSize(am) == 1 && ptr != NULL) + { + *ptr++; + } +#endif // BIGENDIAN + emAfReadOrWriteAttribute(&record, + NULL, // metadata - unused + ptr, + 0, // buffer size - unused + true); // write? + if (writeTokens) + { + emAfSaveAttributeToToken(ptr, de->endpoint, record.clusterId, am); + } + } + } + } + if (endpoint != EMBER_BROADCAST_ENDPOINT) + { + break; } - } - } - if (endpoint != EMBER_BROADCAST_ENDPOINT) { - break; } - } - if (!writeTokens) { - emAfLoadAttributesFromTokens(endpoint); - } + if (!writeTokens) + { + emAfLoadAttributesFromTokens(endpoint); + } } void emAfLoadAttributesFromTokens(uint8_t endpoint) { - // On EZSP host we currently do not support this. We need to come up with some - // callbacks. + // On EZSP host we currently do not support this. We need to come up with some + // callbacks. #ifndef EZSP_HOST - GENERATED_TOKEN_LOADER(endpoint); + GENERATED_TOKEN_LOADER(endpoint); #endif // EZSP_HOST } // 'data' argument may be null, since we changed the ptrToDefaultValue // to be null instead of pointing to all zeroes. // This function has to be able to deal with that. -void emAfSaveAttributeToToken(uint8_t *data, - uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *metadata) +void emAfSaveAttributeToToken(uint8_t * data, uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeMetadata * metadata) { - // Get out of here if this attribute doesn't have a token. - if ( !emberAfAttributeIsTokenized(metadata)) { - return; - } + // Get out of here if this attribute doesn't have a token. + if (!emberAfAttributeIsTokenized(metadata)) + { + return; + } // On EZSP host we currently do not support this. We need to come up with some // callbacks. #ifndef EZSP_HOST - GENERATED_TOKEN_SAVER; + GENERATED_TOKEN_SAVER; #endif // EZSP_HOST } // This function returns the actual function point from the array, // iterating over the function bits. -EmberAfGenericClusterFunction -emberAfFindClusterFunction(EmberAfCluster *cluster, - EmberAfClusterMask functionMask) +EmberAfGenericClusterFunction emberAfFindClusterFunction(EmberAfCluster * cluster, EmberAfClusterMask functionMask) { - EmberAfClusterMask mask = 0x01; - uint8_t functionIndex = 0; + EmberAfClusterMask mask = 0x01; + uint8_t functionIndex = 0; - if ( (cluster->mask & functionMask) == 0 ) { - return NULL; - } + if ((cluster->mask & functionMask) == 0) + { + return NULL; + } - while ( mask < functionMask ) { - if ( (cluster->mask & mask) != 0 ) { - functionIndex++; + while (mask < functionMask) + { + if ((cluster->mask & mask) != 0) + { + functionIndex++; + } + mask <<= 1; } - mask <<= 1; - } - return cluster->functions[functionIndex]; + return cluster->functions[functionIndex]; } #ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY -uint16_t emAfGetManufacturerCodeForCommand(EmberAfCommandMetadata *command) +uint16_t emAfGetManufacturerCodeForCommand(EmberAfCommandMetadata * command) { - return getManufacturerCode((EmberAfManufacturerCodeEntry *)commandManufacturerCodes, - commandManufacturerCodeCount, - (command - generatedCommands)); + return getManufacturerCode((EmberAfManufacturerCodeEntry *) commandManufacturerCodes, commandManufacturerCodeCount, + (command - generatedCommands)); } /** @@ -1229,89 +1207,95 @@ uint16_t emAfGetManufacturerCodeForCommand(EmberAfCommandMetadata *command) * It returns false, if there were more commands, but were not populated * because of maxIdCount limitation. */ -bool emberAfExtractCommandIds(bool outgoing, - EmberAfClusterCommand *cmd, - uint16_t clusterId, - uint8_t *buffer, - uint16_t bufferLength, - uint16_t *bufferIndex, - uint8_t startId, - uint8_t maxIdCount) -{ - uint16_t i, count = 0; - bool returnValue = true; - uint8_t cmdDirMask = 0; - - // determine the appropriate mask to match the request - // discover commands generated, client is asking server what commands do you generate? - if (outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) { - cmdDirMask = COMMAND_MASK_OUTGOING_SERVER; - // discover commands generated server is asking client what commands do you generate? - } else if (outgoing && (cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT)) { - cmdDirMask = COMMAND_MASK_OUTGOING_CLIENT; - // discover commands received client is asking server what commands do you receive? - } else if (!outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) { - cmdDirMask = COMMAND_MASK_INCOMING_SERVER; - // discover commands received server is asking client what commands do you receive? - } else { - cmdDirMask = COMMAND_MASK_INCOMING_CLIENT; - } - - for ( i = 0; i < EMBER_AF_GENERATED_COMMAND_COUNT; i++ ) { - if ( generatedCommands[i].clusterId != clusterId ) { - continue; +bool emberAfExtractCommandIds(bool outgoing, EmberAfClusterCommand * cmd, uint16_t clusterId, uint8_t * buffer, + uint16_t bufferLength, uint16_t * bufferIndex, uint8_t startId, uint8_t maxIdCount) +{ + uint16_t i, count = 0; + bool returnValue = true; + uint8_t cmdDirMask = 0; + + // determine the appropriate mask to match the request + // discover commands generated, client is asking server what commands do you generate? + if (outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) + { + cmdDirMask = COMMAND_MASK_OUTGOING_SERVER; + // discover commands generated server is asking client what commands do you generate? } - - if ((generatedCommands[i].mask & cmdDirMask) == 0 ) { - continue; + else if (outgoing && (cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT)) + { + cmdDirMask = COMMAND_MASK_OUTGOING_CLIENT; + // discover commands received client is asking server what commands do you receive? } - - //Only start from the passed command id - if (generatedCommands[i].commandId < startId) { - continue; + else if (!outgoing && (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER)) + { + cmdDirMask = COMMAND_MASK_INCOMING_SERVER; + // discover commands received server is asking client what commands do you receive? } - - // According to spec: if cmd->mfgSpecific is set, then we ONLY return the - // mfg specific commands. If it's not, then we ONLY return non-mfg specific. - if ( generatedCommands[i].mask & COMMAND_MASK_MANUFACTURER_SPECIFIC ) { - // Command is Mfg specific - if ( !cmd->mfgSpecific ) { - continue; // ignore if asking for not mfg specific - } - if ( cmd->mfgCode != emAfGetManufacturerCodeForCommand( (EmberAfCommandMetadata*) &(generatedCommands[i]))) { - continue; // Ignore if mfg code doesn't match the commands - } - } else { - // Command is not mfg specific. - if ( cmd->mfgSpecific ) { - continue; // Ignore if asking for mfg specific - } + else + { + cmdDirMask = COMMAND_MASK_INCOMING_CLIENT; } - // The one we are about to put in, is beyond the maxIdCount, - // so instead of populating it in, we set the return flag to - // false and get out of here. - if ( maxIdCount == count || count >= bufferLength ) { - returnValue = false; - break; + for (i = 0; i < EMBER_AF_GENERATED_COMMAND_COUNT; i++) + { + if (generatedCommands[i].clusterId != clusterId) + { + continue; + } + + if ((generatedCommands[i].mask & cmdDirMask) == 0) + { + continue; + } + + // Only start from the passed command id + if (generatedCommands[i].commandId < startId) + { + continue; + } + + // According to spec: if cmd->mfgSpecific is set, then we ONLY return the + // mfg specific commands. If it's not, then we ONLY return non-mfg specific. + if (generatedCommands[i].mask & COMMAND_MASK_MANUFACTURER_SPECIFIC) + { + // Command is Mfg specific + if (!cmd->mfgSpecific) + { + continue; // ignore if asking for not mfg specific + } + if (cmd->mfgCode != emAfGetManufacturerCodeForCommand((EmberAfCommandMetadata *) &(generatedCommands[i]))) + { + continue; // Ignore if mfg code doesn't match the commands + } + } + else + { + // Command is not mfg specific. + if (cmd->mfgSpecific) + { + continue; // Ignore if asking for mfg specific + } + } + + // The one we are about to put in, is beyond the maxIdCount, + // so instead of populating it in, we set the return flag to + // false and get out of here. + if (maxIdCount == count || count >= bufferLength) + { + returnValue = false; + break; + } + buffer[count] = generatedCommands[i].commandId; + (*bufferIndex)++; + count++; } - buffer[count] = generatedCommands[i].commandId; - (*bufferIndex)++; - count++; - } - return returnValue; + return returnValue; } #else // We just need an empty stub if we don't support it -bool emberAfExtractCommandIds(bool outgoing, - EmberAfClusterCommand *cmd, - uint16_t clusterId, - uint8_t *buffer, - uint16_t bufferLength, - uint16_t *bufferIndex, - uint8_t startId, - uint8_t maxIdCount) -{ - return true; +bool emberAfExtractCommandIds(bool outgoing, EmberAfClusterCommand * cmd, uint16_t clusterId, uint8_t * buffer, + uint16_t bufferLength, uint16_t * bufferIndex, uint8_t startId, uint8_t maxIdCount) +{ + return true; } #endif diff --git a/examples/wifi-echo/server/esp32/main/attribute-storage.h b/examples/wifi-echo/server/esp32/main/attribute-storage.h index 4fad79592b88d4..0f550250f3730b 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-storage.h +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.h @@ -31,11 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief Contains the per-endpoint configuration of attribute tables. + * @brief Contains the per-endpoint configuration of + *attribute tables. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef __AF_ATTRIBUTE_STORAGE__ #define __AF_ATTRIBUTE_STORAGE__ @@ -43,8 +45,8 @@ //#include PLATFORM_HEADER #include "af.h" -#if !defined (EMBER_SCRIPTED_TEST) - #include "gen/att-storage.h" +#if !defined(EMBER_SCRIPTED_TEST) +#include "gen/att-storage.h" #endif #if !defined(ATTRIBUTE_STORAGE_CONFIGURATION) && defined(EMBER_TEST) @@ -57,9 +59,9 @@ // we use the provider sample. #ifndef ATTRIBUTE_STORAGE_CONFIGURATION // #error "Must define ATTRIBUTE_STORAGE_CONFIGURATION to specify the App. Builder default attributes file." - #include "gen/endpoint_config.h" +#include "gen/endpoint_config.h" #else - #include ATTRIBUTE_STORAGE_CONFIGURATION +#include ATTRIBUTE_STORAGE_CONFIGURATION #endif // If we have fixed number of endpoints, then max is the same. @@ -67,10 +69,10 @@ #define MAX_ENDPOINT_COUNT FIXED_ENDPOINT_COUNT #endif -#define CLUSTER_TICK_FREQ_ALL (0x00) +#define CLUSTER_TICK_FREQ_ALL (0x00) #define CLUSTER_TICK_FREQ_QUARTER_SECOND (0x04) -#define CLUSTER_TICK_FREQ_HALF_SECOND (0x08) -#define CLUSTER_TICK_FREQ_SECOND (0x0C) +#define CLUSTER_TICK_FREQ_HALF_SECOND (0x08) +#define CLUSTER_TICK_FREQ_SECOND (0x0C) extern uint8_t attributeData[]; // main storage bucket for all attributes @@ -78,44 +80,30 @@ extern uint8_t attributeDefaults[]; // storage bucked for > 2b default values void emAfCallInits(void); -#define emberAfClusterIsClient(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_CLIENT) != 0)) -#define emberAfClusterIsServer(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_SERVER) != 0)) -#define emberAfDoesClusterHaveInitFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_INIT_FUNCTION) != 0)) -#define emberAfDoesClusterHaveAttributeChangedFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION) != 0)) -#define emberAfDoesClusterHaveDefaultResponseFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION) != 0)) -#define emberAfDoesClusterHaveMessageSentFunction(cluster) ((bool)(((cluster)->mask & CLUSTER_MASK_MESSAGE_SENT_FUNCTION) != 0)) +#define emberAfClusterIsClient(cluster) ((bool) (((cluster)->mask & CLUSTER_MASK_CLIENT) != 0)) +#define emberAfClusterIsServer(cluster) ((bool) (((cluster)->mask & CLUSTER_MASK_SERVER) != 0)) +#define emberAfDoesClusterHaveInitFunction(cluster) ((bool) (((cluster)->mask & CLUSTER_MASK_INIT_FUNCTION) != 0)) +#define emberAfDoesClusterHaveAttributeChangedFunction(cluster) \ + ((bool) (((cluster)->mask & CLUSTER_MASK_ATTRIBUTE_CHANGED_FUNCTION) != 0)) +#define emberAfDoesClusterHaveDefaultResponseFunction(cluster) \ + ((bool) (((cluster)->mask & CLUSTER_MASK_DEFAULT_RESPONSE_FUNCTION) != 0)) +#define emberAfDoesClusterHaveMessageSentFunction(cluster) ((bool) (((cluster)->mask & CLUSTER_MASK_MESSAGE_SENT_FUNCTION) != 0)) // Initial configuration void emberAfEndpointConfigure(void); -bool emberAfExtractCommandIds(bool outgoing, - EmberAfClusterCommand *cmd, - uint16_t clusterId, - uint8_t *buffer, - uint16_t bufferLength, - uint16_t *bufferIndex, - uint8_t startId, - uint8_t maxIdCount); - -EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord *attRecord, - EmberAfAttributeMetadata **metadata, - uint8_t *buffer, - uint16_t readLength, - bool write); - -bool emAfMatchCluster(EmberAfCluster *cluster, - EmberAfAttributeSearchRecord *attRecord); -bool emAfMatchAttribute(EmberAfCluster *cluster, - EmberAfAttributeMetadata *am, - EmberAfAttributeSearchRecord *attRecord); - -EmberAfCluster *emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType *endpointType, - EmberAfClusterId clusterId, - EmberAfClusterMask mask, - uint16_t manufacturerCode); - -EmberAfCluster *emberAfFindClusterInType(EmberAfEndpointType *endpointType, - EmberAfClusterId clusterId, - EmberAfClusterMask mask); +bool emberAfExtractCommandIds(bool outgoing, EmberAfClusterCommand * cmd, uint16_t clusterId, uint8_t * buffer, + uint16_t bufferLength, uint16_t * bufferIndex, uint8_t startId, uint8_t maxIdCount); + +EmberAfStatus emAfReadOrWriteAttribute(EmberAfAttributeSearchRecord * attRecord, EmberAfAttributeMetadata ** metadata, + uint8_t * buffer, uint16_t readLength, bool write); + +bool emAfMatchCluster(EmberAfCluster * cluster, EmberAfAttributeSearchRecord * attRecord); +bool emAfMatchAttribute(EmberAfCluster * cluster, EmberAfAttributeMetadata * am, EmberAfAttributeSearchRecord * attRecord); + +EmberAfCluster * emberAfFindClusterInTypeWithMfgCode(EmberAfEndpointType * endpointType, EmberAfClusterId clusterId, + EmberAfClusterMask mask, uint16_t manufacturerCode); + +EmberAfCluster * emberAfFindClusterInType(EmberAfEndpointType * endpointType, EmberAfClusterId clusterId, EmberAfClusterMask mask); // This function returns the index of cluster for the particular endpoint. // Mask is either CLUSTER_MASK_CLIENT or CLUSTER_MASK_SERVER @@ -127,9 +115,7 @@ EmberAfCluster *emberAfFindClusterInType(EmberAfEndpointType *endpointType, // clusterIndex(Y,10,CLUSTER_MASK_SERVER) returns 0 // clusterIndex(Y,11,CLUSTER_MASK_SERVER) returns 0xFF // clusterIndex(Y,12,CLUSTER_MASK_SERVER) returns 0xFF -uint8_t emberAfClusterIndex(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask); +uint8_t emberAfClusterIndex(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask); // If server == true, returns the number of server clusters, // otherwise number of client clusters on this endpoint @@ -137,36 +123,34 @@ uint8_t emberAfClusterCount(uint8_t endpoint, bool server); // Returns the clusterId of Nth server or client cluster, // depending on server toggle. -EmberAfCluster *emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server); +EmberAfCluster * emberAfGetNthCluster(uint8_t endpoint, uint8_t n, bool server); // Returns number of clusters put into the passed cluster list // for the given endpoint and client/server polarity -uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId *clusterList, uint8_t listLen, bool server); +uint8_t emberAfGetClustersFromEndpoint(uint8_t endpoint, EmberAfClusterId * clusterList, uint8_t listLen, bool server); // Returns cluster within the endpoint, or NULL if it isn't there -EmberAfCluster *emberAfFindClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask, uint16_t manufacturerCode); +EmberAfCluster * emberAfFindClusterWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask, + uint16_t manufacturerCode); // Returns cluster within the endpoint, or NULL if it isn't there // This wraps emberAfFindClusterWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE -EmberAfCluster *emberAfFindCluster(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask); +EmberAfCluster * emberAfFindCluster(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfClusterMask mask); // Returns cluster within the endpoint; Does not ignore disabled endpoints -EmberAfCluster *emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask, - uint16_t manufacturerCode); +EmberAfCluster * emberAfFindClusterIncludingDisabledEndpointsWithMfgCode(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfClusterMask mask, uint16_t manufacturerCode); // Returns cluster within the endpoint; Does not ignore disabled endpoints // This wraps emberAfFindClusterIncludingDisabledEndpointsWithMfgCode with EMBER_AF_NULL_MANUFACTURER_CODE -EmberAfCluster *emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfClusterMask mask); +EmberAfCluster * emberAfFindClusterIncludingDisabledEndpoints(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfClusterMask mask); // Function mask must contain one of the CLUSTER_MASK function macros, // then this method either returns the function pointer or null if // function doesn't exist. Before you call the function, you must // cast it. -EmberAfGenericClusterFunction emberAfFindClusterFunction(EmberAfCluster *cluster, EmberAfClusterMask functionMask); +EmberAfGenericClusterFunction emberAfFindClusterFunction(EmberAfCluster * cluster, EmberAfClusterMask functionMask); // Public APIs for loading attributes void emberAfInitializeAttributes(uint8_t endpoint); @@ -183,70 +167,42 @@ void emAfLoadAttributesFromTokens(uint8_t endpoint); // function. If this attribute has been // tagged as stored-to-token, then code will store // the attribute to token. -void emAfSaveAttributeToToken(uint8_t *data, - uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *metadata); +void emAfSaveAttributeToToken(uint8_t * data, uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeMetadata * metadata); // Calls the attribute changed callback -void emAfClusterAttributeChangedCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t clientServerMask, - uint16_t manufacturerCode); +void emAfClusterAttributeChangedCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t clientServerMask, uint16_t manufacturerCode); // Calls the attribute changed callback for a specific cluster. -EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t clientServerMask, - uint16_t manufacturerCode, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t* value); +EmberAfStatus emAfClusterPreAttributeChangedCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t clientServerMask, uint16_t manufacturerCode, + EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); // Calls the default response callback for a specific cluster, and wraps emberAfClusterDefaultResponseWithMfgCodeCallback // with the EMBER_NULL_MANUFACTURER_CODE -void emberAfClusterDefaultResponseCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status, +void emberAfClusterDefaultResponseCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t commandId, EmberAfStatus status, uint8_t clientServerMask); // Calls the default response callback for a specific cluster. -void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status, - uint8_t clientServerMask, - uint16_t manufacturerCode); +void emberAfClusterDefaultResponseWithMfgCodeCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint8_t commandId, + EmberAfStatus status, uint8_t clientServerMask, uint16_t manufacturerCode); // Calls the message sent callback for a specific cluster, and wraps emberAfClusterMessageSentWithMfgCodeCallback -void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfClusterMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); // Calls the message sent callback for a specific cluster. -void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status, +void emberAfClusterMessageSentWithMfgCodeCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status, uint16_t manufacturerCode); // Used to retrieve a manufacturer code from an attribute metadata -uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster *cluster); -uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster *cluster, - EmberAfAttributeMetadata *attMetaData); +uint16_t emAfGetManufacturerCodeForCluster(EmberAfCluster * cluster); +uint16_t emAfGetManufacturerCodeForAttribute(EmberAfCluster * cluster, EmberAfAttributeMetadata * attMetaData); // Checks a cluster mask byte against ticks passed bitmask // returns true if the mask matches a passed interval -bool emberAfCheckTick(EmberAfClusterMask mask, - uint8_t passedMask); +bool emberAfCheckTick(EmberAfClusterMask mask, uint8_t passedMask); bool emberAfEndpointIsEnabled(uint8_t endpoint); @@ -260,7 +216,7 @@ bool emberAfEndpointIsEnabled(uint8_t endpoint); // // Don't mix them. uint8_t emberAfGetClusterCountForEndpoint(uint8_t endpoint); -EmberAfCluster* emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex); +EmberAfCluster * emberAfGetClusterByIndex(uint8_t endpoint, uint8_t clusterIndex); EmberAfProfileId emberAfGetProfileIdForEndpoint(uint8_t endpoint); uint16_t emberAfGetDeviceIdForEndpoint(uint8_t endpoint); diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.c b/examples/wifi-echo/server/esp32/main/attribute-table.c index 1b78617fa34fda..ede422b07abd4a 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-table.c +++ b/examples/wifi-echo/server/esp32/main/attribute-table.c @@ -31,13 +31,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains the code to manipulate the Smart Energy attribute - * table. This handles external calls to read/write the table, as - * well as internal ones. + * @brief This file contains the code to manipulate + *the Smart Energy attribute table. This handles + *external calls to read/write the table, as well as + *internal ones. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ // this file contains all the common includes for clusters in the zcl-util #include "common.h" @@ -60,397 +62,272 @@ //------------------------------------------------------------------------------ // Globals -EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* dataPtr, +EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t mask, uint16_t manufacturerCode, uint8_t * dataPtr, EmberAfAttributeType dataType) { - EmberAfAttributeWritePermission extWritePermission - = emberAfAllowNetworkWriteAttributeCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataPtr, - dataType); - switch (extWritePermission) { + EmberAfAttributeWritePermission extWritePermission = + emberAfAllowNetworkWriteAttributeCallback(endpoint, cluster, attributeID, mask, manufacturerCode, dataPtr, dataType); + switch (extWritePermission) + { case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_DENY_WRITE: - return EMBER_ZCL_STATUS_FAILURE; + return EMBER_ZCL_STATUS_FAILURE; case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL: case EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY: - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataPtr, - dataType, - (extWritePermission - == EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY), - false); + return emAfWriteAttribute(endpoint, cluster, attributeID, mask, manufacturerCode, dataPtr, dataType, + (extWritePermission == EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY), false); default: - return (EmberAfStatus)extWritePermission; - } + return (EmberAfStatus) extWritePermission; + } } //@deprecated use emberAfWriteServerAttribute or emberAfWriteClientAttribute -EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfWriteAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - mask, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - dataType, - true, // override read-only? - false); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, mask, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, dataType, + true, // override read-only? + false); // just test? } -EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfWriteClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_CLIENT, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - dataType, - true, // override read-only? - false); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_CLIENT, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, + dataType, + true, // override read-only? + false); // just test? } -EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfWriteServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_SERVER, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - dataType, - true, // override read-only? - false); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, + dataType, + true, // override read-only? + false); // just test? } -EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfWriteManufacturerSpecificClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_CLIENT, - manufacturerCode, - dataPtr, - dataType, - true, // override read-only? - false); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_CLIENT, manufacturerCode, dataPtr, dataType, + true, // override read-only? + false); // just test? } -EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfWriteManufacturerSpecificServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_SERVER, - manufacturerCode, - dataPtr, - dataType, - true, // override read-only? - false); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_SERVER, manufacturerCode, dataPtr, dataType, + true, // override read-only? + false); // just test? } -EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* dataPtr, - EmberAfAttributeType dataType) +EmberAfStatus emberAfVerifyAttributeWrite(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * dataPtr, EmberAfAttributeType dataType) { - return emAfWriteAttribute(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataPtr, - dataType, - false, // override read-only? - true); // just test? + return emAfWriteAttribute(endpoint, cluster, attributeID, mask, manufacturerCode, dataPtr, dataType, + false, // override read-only? + true); // just test? } -EmberAfStatus emberAfReadAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint8_t *dataPtr, - uint8_t readLength, - EmberAfAttributeType *dataType) +EmberAfStatus emberAfReadAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint8_t * dataPtr, uint8_t readLength, EmberAfAttributeType * dataType) { - return emAfReadAttribute(endpoint, - cluster, - attributeID, - mask, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - readLength, - dataType); + return emAfReadAttribute(endpoint, cluster, attributeID, mask, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, readLength, dataType); } -EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - uint8_t readLength) +EmberAfStatus emberAfReadServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, uint8_t readLength) { - return emAfReadAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_SERVER, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - readLength, - NULL); + return emAfReadAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, + readLength, NULL); } -EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t* dataPtr, - uint8_t readLength) +EmberAfStatus emberAfReadClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t * dataPtr, uint8_t readLength) { - return emAfReadAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_CLIENT, - EMBER_AF_NULL_MANUFACTURER_CODE, - dataPtr, - readLength, - NULL); + return emAfReadAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_CLIENT, EMBER_AF_NULL_MANUFACTURER_CODE, dataPtr, + readLength, NULL); } -EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - uint8_t readLength) +EmberAfStatus emberAfReadManufacturerSpecificServerAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, uint8_t readLength) { - return emAfReadAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_SERVER, - manufacturerCode, - dataPtr, - readLength, - NULL); + return emAfReadAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_SERVER, manufacturerCode, dataPtr, readLength, NULL); } -EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint16_t manufacturerCode, - uint8_t* dataPtr, - uint8_t readLength) +EmberAfStatus emberAfReadManufacturerSpecificClientAttribute(uint8_t endpoint, EmberAfClusterId cluster, + EmberAfAttributeId attributeID, uint16_t manufacturerCode, + uint8_t * dataPtr, uint8_t readLength) { - return emAfReadAttribute(endpoint, - cluster, - attributeID, - CLUSTER_MASK_CLIENT, - manufacturerCode, - dataPtr, - readLength, - NULL); + return emAfReadAttribute(endpoint, cluster, attributeID, CLUSTER_MASK_CLIENT, manufacturerCode, dataPtr, readLength, NULL); } -bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId startAttributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t maxAttributeIds, +bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId startAttributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t maxAttributeIds, bool includeAccessControl) { - uint16_t i; - uint16_t discovered = 0; - uint16_t skipped = 0; - uint16_t total = 0; - - EmberAfCluster *cluster = emberAfFindClusterWithMfgCode(endpoint, - clusterId, - mask, - manufacturerCode); - - EmberAfAttributeSearchRecord record; - record.endpoint = endpoint; - record.clusterId = clusterId; - record.clusterMask = mask; - record.attributeId = startAttributeId; - record.manufacturerCode = manufacturerCode; - - // If we don't have the cluster or it doesn't match the search, we're done. - if (cluster == NULL || !emAfMatchCluster(cluster, &record)) { - return true; - } - - for (i = 0; i < cluster->attributeCount; i++) { - EmberAfAttributeMetadata *metadata = &cluster->attributes[i]; - - // If the cluster is not manufacturer-specific, an attribute is considered - // only if its manufacturer code matches that of the command (which may be - // unset). - if (!emberAfClusterIsManufacturerSpecific(cluster)) { - record.attributeId = metadata->attributeId; - if (!emAfMatchAttribute(cluster, metadata, &record)) { - continue; - } + uint16_t i; + uint16_t discovered = 0; + uint16_t skipped = 0; + uint16_t total = 0; + + EmberAfCluster * cluster = emberAfFindClusterWithMfgCode(endpoint, clusterId, mask, manufacturerCode); + + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = clusterId; + record.clusterMask = mask; + record.attributeId = startAttributeId; + record.manufacturerCode = manufacturerCode; + + // If we don't have the cluster or it doesn't match the search, we're done. + if (cluster == NULL || !emAfMatchCluster(cluster, &record)) + { + return true; } - if (metadata->attributeId < startAttributeId) { - skipped++; - } else if (discovered < maxAttributeIds) { - emberAfPutInt16uInResp(metadata->attributeId); - emberAfPutInt8uInResp(metadata->attributeType); - if (includeAccessControl) { - // bit 0 : Readable <-- All our attributes are readable - // bit 1 : Writable <-- The only thing we track in the attribute metadata mask - // bit 2 : Reportable <-- All our attributes are reportable - emberAfPutInt8uInResp((metadata->mask & ATTRIBUTE_MASK_WRITABLE) - ? 0x07 - : 0x05); - } - discovered++; - } else { - // MISRA requires ..else if.. to have terminating else. + for (i = 0; i < cluster->attributeCount; i++) + { + EmberAfAttributeMetadata * metadata = &cluster->attributes[i]; + + // If the cluster is not manufacturer-specific, an attribute is considered + // only if its manufacturer code matches that of the command (which may be + // unset). + if (!emberAfClusterIsManufacturerSpecific(cluster)) + { + record.attributeId = metadata->attributeId; + if (!emAfMatchAttribute(cluster, metadata, &record)) + { + continue; + } + } + + if (metadata->attributeId < startAttributeId) + { + skipped++; + } + else if (discovered < maxAttributeIds) + { + emberAfPutInt16uInResp(metadata->attributeId); + emberAfPutInt8uInResp(metadata->attributeType); + if (includeAccessControl) + { + // bit 0 : Readable <-- All our attributes are readable + // bit 1 : Writable <-- The only thing we track in the attribute metadata mask + // bit 2 : Reportable <-- All our attributes are reportable + emberAfPutInt8uInResp((metadata->mask & ATTRIBUTE_MASK_WRITABLE) ? 0x07 : 0x05); + } + discovered++; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } + total++; } - total++; - } - - // We are finished if there are no more attributes to find, which means the - // number of attributes discovered plus the number skipped equals the total - // attributes in the cluster. For manufacturer-specific clusters, the total - // includes all attributes in the cluster. For standard ZCL clusters, if the - // the manufacturer code is set, the total is the number of attributes that - // match the manufacturer code. Otherwise, the total is the number of - // standard ZCL attributes in the cluster. - return (discovered + skipped == total); + + // We are finished if there are no more attributes to find, which means the + // number of attributes discovered plus the number skipped equals the total + // attributes in the cluster. For manufacturer-specific clusters, the total + // includes all attributes in the cluster. For standard ZCL clusters, if the + // the manufacturer code is set, the total is the number of attributes that + // match the manufacturer code. Otherwise, the total is the number of + // standard ZCL attributes in the cluster. + return (discovered + skipped == total); } static void emberAfAttributeDecodeAndPrintCluster(EmberAfClusterId cluster, uint16_t mfgCode) { #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) - uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); - if (index != 0xFFFF) { - emberAfAttributesPrintln("(%p)", zclClusterNames[index].name); - } - emberAfAttributesFlush(); -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) + uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); + if (index != 0xFFFF) + { + emberAfAttributesPrintln("(%p)", zclClusterNames[index].name); + } + emberAfAttributesFlush(); +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) } void emberAfPrintAttributeTable(void) { - uint8_t data[ATTRIBUTE_LARGEST]; - uint8_t endpointIndex, clusterIndex; - uint16_t attributeIndex; - EmberAfStatus status; - uint16_t mfgCode; - for (endpointIndex = 0; - endpointIndex < emberAfEndpointCount(); - endpointIndex++) { - EmberAfDefinedEndpoint *ep = &(emAfEndpoints[endpointIndex]); - emberAfAttributesPrintln("ENDPOINT %x", ep->endpoint); - emberAfAttributesPrintln("clus / side / attr / mfg /type(len)/ rw / storage / data (raw)"); - emberAfAttributesFlush(); - for (clusterIndex = 0; - clusterIndex < ep->endpointType->clusterCount; - clusterIndex++) { - EmberAfCluster *cluster = &(ep->endpointType->cluster[clusterIndex]); - - for (attributeIndex = 0; - attributeIndex < cluster->attributeCount; - attributeIndex++) { - EmberAfAttributeMetadata *metaData = &(cluster->attributes[attributeIndex]); - - // Depending on user config, this loop can take a very long time to - // run and watchdog reset will kick in. As a workaround, we'll - // manually reset the watchdog. - // halResetWatchdog(); - - emberAfAttributesPrint("%2x / %p / %2x / ", - cluster->clusterId, - (emberAfAttributeIsClient(metaData) ? "clnt" : "srvr"), - metaData->attributeId); - mfgCode = emAfGetManufacturerCodeForAttribute(cluster, metaData); - if (mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) { - emberAfAttributesPrint("----"); - } else { - emberAfAttributesPrint("%2x", mfgCode); - } - emberAfAttributesPrint(" / %x (%x) / %p / %p / ", - metaData->attributeType, - emberAfAttributeSize(metaData), - (emberAfAttributeIsReadOnly(metaData) ? "RO" : "RW"), - (emberAfAttributeIsTokenized(metaData) - ? " token " - : (emberAfAttributeIsExternal(metaData) - ? "extern " - : " RAM "))); + uint8_t data[ATTRIBUTE_LARGEST]; + uint8_t endpointIndex, clusterIndex; + uint16_t attributeIndex; + EmberAfStatus status; + uint16_t mfgCode; + for (endpointIndex = 0; endpointIndex < emberAfEndpointCount(); endpointIndex++) + { + EmberAfDefinedEndpoint * ep = &(emAfEndpoints[endpointIndex]); + emberAfAttributesPrintln("ENDPOINT %x", ep->endpoint); + emberAfAttributesPrintln("clus / side / attr / mfg /type(len)/ rw / storage / data (raw)"); emberAfAttributesFlush(); - status = emAfReadAttribute(ep->endpoint, - cluster->clusterId, - metaData->attributeId, - (emberAfAttributeIsClient(metaData) - ? CLUSTER_MASK_CLIENT - : CLUSTER_MASK_SERVER), - mfgCode, - data, - ATTRIBUTE_LARGEST, - NULL); - if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) { - emberAfAttributesPrintln("Unsupported"); - } else { - uint16_t length; - if (emberAfIsStringAttributeType(metaData->attributeType)) { - length = emberAfStringLength(data) + 1; - } else if (emberAfIsLongStringAttributeType(metaData->attributeType)) { - length = emberAfLongStringLength(data) + 2; - } else { - length = emberAfAttributeSize(metaData); - } - UNUSED_VAR(length); - emberAfAttributesPrintBuffer(data, length, true); - emberAfAttributesFlush(); - emberAfAttributeDecodeAndPrintCluster(cluster->clusterId, mfgCode); + for (clusterIndex = 0; clusterIndex < ep->endpointType->clusterCount; clusterIndex++) + { + EmberAfCluster * cluster = &(ep->endpointType->cluster[clusterIndex]); + + for (attributeIndex = 0; attributeIndex < cluster->attributeCount; attributeIndex++) + { + EmberAfAttributeMetadata * metaData = &(cluster->attributes[attributeIndex]); + + // Depending on user config, this loop can take a very long time to + // run and watchdog reset will kick in. As a workaround, we'll + // manually reset the watchdog. + // halResetWatchdog(); + + emberAfAttributesPrint("%2x / %p / %2x / ", cluster->clusterId, + (emberAfAttributeIsClient(metaData) ? "clnt" : "srvr"), metaData->attributeId); + mfgCode = emAfGetManufacturerCodeForAttribute(cluster, metaData); + if (mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) + { + emberAfAttributesPrint("----"); + } + else + { + emberAfAttributesPrint("%2x", mfgCode); + } + emberAfAttributesPrint(" / %x (%x) / %p / %p / ", metaData->attributeType, emberAfAttributeSize(metaData), + (emberAfAttributeIsReadOnly(metaData) ? "RO" : "RW"), + (emberAfAttributeIsTokenized(metaData) + ? " token " + : (emberAfAttributeIsExternal(metaData) ? "extern " : " RAM "))); + emberAfAttributesFlush(); + status = emAfReadAttribute(ep->endpoint, cluster->clusterId, metaData->attributeId, + (emberAfAttributeIsClient(metaData) ? CLUSTER_MASK_CLIENT : CLUSTER_MASK_SERVER), + mfgCode, data, ATTRIBUTE_LARGEST, NULL); + if (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) + { + emberAfAttributesPrintln("Unsupported"); + } + else + { + uint16_t length; + if (emberAfIsStringAttributeType(metaData->attributeType)) + { + length = emberAfStringLength(data) + 1; + } + else if (emberAfIsLongStringAttributeType(metaData->attributeType)) + { + length = emberAfLongStringLength(data) + 2; + } + else + { + length = emberAfAttributeSize(metaData); + } + UNUSED_VAR(length); + emberAfAttributesPrintBuffer(data, length, true); + emberAfAttributesFlush(); + emberAfAttributeDecodeAndPrintCluster(cluster->clusterId, mfgCode); + } + } } - } + emberAfAttributesFlush(); } - emberAfAttributesFlush(); - } } // given a clusterId and an attribute to read, this crafts the response @@ -458,83 +335,75 @@ void emberAfPrintAttributeTable(void) // 1) unsupported: [attrId:2] [status:1] // 2) supported: [attrId:2] [status:1] [type:1] [data:n] // -void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attrId, - uint8_t mask, - uint16_t manufacturerCode, - uint16_t readLength) +void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, + uint16_t manufacturerCode, uint16_t readLength) { - EmberAfStatus status; - uint8_t data[ATTRIBUTE_LARGEST]; - uint8_t dataType; - uint16_t dataLen; - - // account for at least one byte of data - if (readLength < 5) { - return; - } - - emberAfAttributesPrintln("OTA READ: ep:%x cid:%2x attid:%2x msk:%x mfcode:%2x", - endpoint, - clusterId, attrId, mask, manufacturerCode); - - // lookup the attribute in our table - status = emAfReadAttribute(endpoint, - clusterId, - attrId, - mask, - manufacturerCode, - data, - ATTRIBUTE_LARGEST, - &dataType); - if (status == EMBER_ZCL_STATUS_SUCCESS) { - dataLen = emberAfAttributeValueSize(dataType, data); - if ((readLength - 4) < dataLen) { // Not enough space for attribute. - return; + EmberAfStatus status; + uint8_t data[ATTRIBUTE_LARGEST]; + uint8_t dataType; + uint16_t dataLen; + + // account for at least one byte of data + if (readLength < 5) + { + return; } - } else { - emberAfPutInt16uInResp(attrId); - emberAfPutInt8uInResp(status); - emberAfAttributesPrintln("READ: clus %2x, attr %2x failed %x", - clusterId, - attrId, - status); - emberAfAttributesFlush(); - return; - } - // put attribute in least sig byte first - emberAfPutInt16uInResp(attrId); + emberAfAttributesPrintln("OTA READ: ep:%x cid:%2x attid:%2x msk:%x mfcode:%2x", endpoint, clusterId, attrId, mask, + manufacturerCode); + + // lookup the attribute in our table + status = emAfReadAttribute(endpoint, clusterId, attrId, mask, manufacturerCode, data, ATTRIBUTE_LARGEST, &dataType); + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + dataLen = emberAfAttributeValueSize(dataType, data); + if ((readLength - 4) < dataLen) + { // Not enough space for attribute. + return; + } + } + else + { + emberAfPutInt16uInResp(attrId); + emberAfPutInt8uInResp(status); + emberAfAttributesPrintln("READ: clus %2x, attr %2x failed %x", clusterId, attrId, status); + emberAfAttributesFlush(); + return; + } - // attribute is found, so copy in the status and the data type - emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); - emberAfPutInt8uInResp(dataType); + // put attribute in least sig byte first + emberAfPutInt16uInResp(attrId); + + // attribute is found, so copy in the status and the data type + emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); + emberAfPutInt8uInResp(dataType); - if (dataLen < (EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength)) { + if (dataLen < (EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength)) + { #if (BIGENDIAN_CPU) - // strings go over the air as length byte and then in human - // readable format. These should not be flipped. Other attributes - // need to be flipped so they go little endian OTA - if (isThisDataTypeSentLittleEndianOTA(dataType)) { - uint8_t i; - for (i = 0; i < dataLen; i++) { - appResponseData[appResponseLength + i] = data[dataLen - i - 1]; - } - } else { - MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); - } -#else //(BIGENDIAN_CPU) - MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); + // strings go over the air as length byte and then in human + // readable format. These should not be flipped. Other attributes + // need to be flipped so they go little endian OTA + if (isThisDataTypeSentLittleEndianOTA(dataType)) + { + uint8_t i; + for (i = 0; i < dataLen; i++) + { + appResponseData[appResponseLength + i] = data[dataLen - i - 1]; + } + } + else + { + MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); + } +#else //(BIGENDIAN_CPU) + MEMMOVE(&(appResponseData[appResponseLength]), data, dataLen); #endif //(BIGENDIAN_CPU) - appResponseLength += dataLen; - } - - emberAfAttributesPrintln("READ: clus %2x, attr %2x, dataLen: %x, OK", - clusterId, - attrId, - dataLen); - emberAfAttributesFlush(); + appResponseLength += dataLen; + } + + emberAfAttributesPrintln("READ: clus %2x, attr %2x, dataLen: %x, OK", clusterId, attrId, dataLen); + emberAfAttributesFlush(); } // This function appends the attribute report fields for the given endpoint, @@ -542,59 +411,50 @@ void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, // insufficient space in the buffer or an error occurs, buffer and bufIndex will // remain unchanged. Otherwise, bufIndex will be incremented appropriately and // the fields will be written to the buffer. -EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint8_t *buffer, - uint8_t bufLen, - uint8_t *bufIndex) +EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint8_t * buffer, uint8_t bufLen, uint8_t * bufIndex) { - EmberAfStatus status; - EmberAfAttributeType type; - uint16_t size; - uint16_t bufLen16 = (uint16_t) bufLen; - uint8_t data[ATTRIBUTE_LARGEST]; - - status = emberAfReadAttribute(endpoint, - clusterId, - attributeId, - mask, - data, - sizeof(data), - &type); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - goto kickout; - } - - size = emberAfAttributeValueSize(type, data); - if (bufLen16 - *bufIndex < 3 || size > bufLen16 - (*bufIndex + 3)) { - status = EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; - goto kickout; - } - - buffer[(*bufIndex)++] = LOW_BYTE(attributeId); - buffer[(*bufIndex)++] = HIGH_BYTE(attributeId); - buffer[(*bufIndex)++] = type; + EmberAfStatus status; + EmberAfAttributeType type; + uint16_t size; + uint16_t bufLen16 = (uint16_t) bufLen; + uint8_t data[ATTRIBUTE_LARGEST]; + + status = emberAfReadAttribute(endpoint, clusterId, attributeId, mask, data, sizeof(data), &type); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + goto kickout; + } + + size = emberAfAttributeValueSize(type, data); + if (bufLen16 - *bufIndex < 3 || size > bufLen16 - (*bufIndex + 3)) + { + status = EMBER_ZCL_STATUS_INSUFFICIENT_SPACE; + goto kickout; + } + + buffer[(*bufIndex)++] = LOW_BYTE(attributeId); + buffer[(*bufIndex)++] = HIGH_BYTE(attributeId); + buffer[(*bufIndex)++] = type; #if (BIGENDIAN_CPU) - if (isThisDataTypeSentLittleEndianOTA(type)) { - emberReverseMemCopy(buffer + *bufIndex, data, size); - } else { - MEMMOVE(buffer + *bufIndex, data, size); - } + if (isThisDataTypeSentLittleEndianOTA(type)) + { + emberReverseMemCopy(buffer + *bufIndex, data, size); + } + else + { + MEMMOVE(buffer + *bufIndex, data, size); + } #else - MEMMOVE(buffer + *bufIndex, data, size); + MEMMOVE(buffer + *bufIndex, data, size); #endif - *bufIndex += size; + *bufIndex += size; - kickout: - emberAfAttributesPrintln("REPORT: clus 0x%2x, attr 0x%2x: 0x%x", - clusterId, - attributeId, - status); - emberAfAttributesFlush(); +kickout: + emberAfAttributesPrintln("REPORT: clus 0x%2x, attr 0x%2x: 0x%x", clusterId, attributeId, status); + emberAfAttributesFlush(); - return status; + return status; } //------------------------------------------------------------------------------ @@ -621,206 +481,179 @@ EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, // the table or the data is too large, returns true and writes to dataPtr // if the attribute is supported and the readLength specified is less than // the length of the data. -EmberAfStatus emAfWriteAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t *data, - EmberAfAttributeType dataType, - bool overrideReadOnlyAndDataType, - bool justTest) +EmberAfStatus emAfWriteAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * data, EmberAfAttributeType dataType, + bool overrideReadOnlyAndDataType, bool justTest) { - EmberAfAttributeMetadata *metadata = NULL; - EmberAfAttributeSearchRecord record; - record.endpoint = endpoint; - record.clusterId = cluster; - record.clusterMask = mask; - record.attributeId = attributeID; - record.manufacturerCode = manufacturerCode; - emAfReadOrWriteAttribute(&record, - &metadata, - NULL, // buffer - 0, // buffer size - false); // write? - - // if we dont support that attribute - if (metadata == NULL) { - emberAfAttributesPrintln("%pep %x clus %2x attr %2x not supported", - "WRITE ERR: ", - endpoint, - cluster, - attributeID); - emberAfAttributesFlush(); - return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; - } - - // if the data type specified by the caller is incorrect - if (!(overrideReadOnlyAndDataType)) { - if (dataType != metadata->attributeType) { - emberAfAttributesPrintln("%pinvalid data type", "WRITE ERR: "); - emberAfAttributesFlush(); - return EMBER_ZCL_STATUS_INVALID_DATA_TYPE; + EmberAfAttributeMetadata * metadata = NULL; + EmberAfAttributeSearchRecord record; + record.endpoint = endpoint; + record.clusterId = cluster; + record.clusterMask = mask; + record.attributeId = attributeID; + record.manufacturerCode = manufacturerCode; + emAfReadOrWriteAttribute(&record, &metadata, + NULL, // buffer + 0, // buffer size + false); // write? + + // if we dont support that attribute + if (metadata == NULL) + { + emberAfAttributesPrintln("%pep %x clus %2x attr %2x not supported", "WRITE ERR: ", endpoint, cluster, attributeID); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE; } - if (emberAfAttributeIsReadOnly(metadata)) { - emberAfAttributesPrintln("%pattr not writable", "WRITE ERR: "); - emberAfAttributesFlush(); - return EMBER_ZCL_STATUS_READ_ONLY; - } - } - - // if the value the attribute is being set to is out of range - // return EMBER_ZCL_STATUS_INVALID_VALUE - if ((metadata->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) { - EmberAfDefaultAttributeValue minv = metadata->defaultValue.ptrToMinMaxValue->minValue; - EmberAfDefaultAttributeValue maxv = metadata->defaultValue.ptrToMinMaxValue->maxValue; - bool isAttributeSigned = emberAfIsTypeSigned(metadata->attributeType); - uint8_t dataLen = emberAfAttributeSize(metadata); - if (dataLen <= 2) { - int8_t minR, maxR; - uint8_t* minI = (uint8_t*)&(minv.defaultValue); - uint8_t* maxI = (uint8_t*)&(maxv.defaultValue); - //On big endian cpu with length 1 only the second byte counts - #if (BIGENDIAN_CPU) - if (dataLen == 1) { - minI++; - maxI++; - } - #endif //BIGENDIAN_CPU - minR = emberAfCompareValues(minI, data, dataLen, isAttributeSigned); - maxR = emberAfCompareValues(maxI, data, dataLen, isAttributeSigned); - if ((minR == 1) || (maxR == -1)) { - return EMBER_ZCL_STATUS_INVALID_VALUE; - } - } else { - if ((emberAfCompareValues(minv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == 1) - || (emberAfCompareValues(maxv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == -1)) { - return EMBER_ZCL_STATUS_INVALID_VALUE; - } - } - } - - // write the data unless this is only a test - if (!justTest) { - // Pre write attribute callback for all attribute changes, - // regardless of cluster. - EmberAfStatus status - = emberAfPreAttributeChangeCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataType, - emberAfAttributeSize(metadata), - data); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - return status; + // if the data type specified by the caller is incorrect + if (!(overrideReadOnlyAndDataType)) + { + if (dataType != metadata->attributeType) + { + emberAfAttributesPrintln("%pinvalid data type", "WRITE ERR: "); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_INVALID_DATA_TYPE; + } + + if (emberAfAttributeIsReadOnly(metadata)) + { + emberAfAttributesPrintln("%pattr not writable", "WRITE ERR: "); + emberAfAttributesFlush(); + return EMBER_ZCL_STATUS_READ_ONLY; + } } - // Pre-write attribute callback specific - // to the cluster that the attribute lives in. - status = emAfClusterPreAttributeChangedCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataType, - emberAfAttributeSize(metadata), - data); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - return status; + // if the value the attribute is being set to is out of range + // return EMBER_ZCL_STATUS_INVALID_VALUE + if ((metadata->mask & ATTRIBUTE_MASK_MIN_MAX) != 0U) + { + EmberAfDefaultAttributeValue minv = metadata->defaultValue.ptrToMinMaxValue->minValue; + EmberAfDefaultAttributeValue maxv = metadata->defaultValue.ptrToMinMaxValue->maxValue; + bool isAttributeSigned = emberAfIsTypeSigned(metadata->attributeType); + uint8_t dataLen = emberAfAttributeSize(metadata); + if (dataLen <= 2) + { + int8_t minR, maxR; + uint8_t * minI = (uint8_t *) &(minv.defaultValue); + uint8_t * maxI = (uint8_t *) &(maxv.defaultValue); +// On big endian cpu with length 1 only the second byte counts +#if (BIGENDIAN_CPU) + if (dataLen == 1) + { + minI++; + maxI++; + } +#endif // BIGENDIAN_CPU + minR = emberAfCompareValues(minI, data, dataLen, isAttributeSigned); + maxR = emberAfCompareValues(maxI, data, dataLen, isAttributeSigned); + if ((minR == 1) || (maxR == -1)) + { + return EMBER_ZCL_STATUS_INVALID_VALUE; + } + } + else + { + if ((emberAfCompareValues(minv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == 1) || + (emberAfCompareValues(maxv.ptrToDefaultValue, data, dataLen, isAttributeSigned) == -1)) + { + return EMBER_ZCL_STATUS_INVALID_VALUE; + } + } } - // write the attribute - status = emAfReadOrWriteAttribute(&record, - NULL, // metadata - data, - 0, // buffer size - unused - true); // write? + // write the data unless this is only a test + if (!justTest) + { + // Pre write attribute callback for all attribute changes, + // regardless of cluster. + EmberAfStatus status = emberAfPreAttributeChangeCallback(endpoint, cluster, attributeID, mask, manufacturerCode, dataType, + emberAfAttributeSize(metadata), data); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + return status; + } - if (status != EMBER_ZCL_STATUS_SUCCESS) { - return status; - } + // Pre-write attribute callback specific + // to the cluster that the attribute lives in. + status = emAfClusterPreAttributeChangedCallback(endpoint, cluster, attributeID, mask, manufacturerCode, dataType, + emberAfAttributeSize(metadata), data); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + return status; + } - // Save the attribute to token if needed - // Function itself will weed out tokens that are not tokenized. - emAfSaveAttributeToToken(data, endpoint, cluster, metadata); - - emberAfReportingAttributeChangeCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataType, - data); - - // Post write attribute callback for all attributes changes, regardless - // of cluster. - emberAfPostAttributeChangeCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode, - dataType, - emberAfAttributeSize(metadata), - data); - - // Post-write attribute callback specific - // to the cluster that the attribute lives in. - emAfClusterAttributeChangedCallback(endpoint, - cluster, - attributeID, - mask, - manufacturerCode); - } else { - // bug: 11618, we are not handling properly external attributes - // in this case... We need to do something. We don't really - // know if it will succeed. - emberAfAttributesPrintln("WRITE: no write, just a test"); - emberAfAttributesFlush(); - } + // write the attribute + status = emAfReadOrWriteAttribute(&record, + NULL, // metadata + data, + 0, // buffer size - unused + true); // write? + + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + return status; + } + + // Save the attribute to token if needed + // Function itself will weed out tokens that are not tokenized. + emAfSaveAttributeToToken(data, endpoint, cluster, metadata); + + emberAfReportingAttributeChangeCallback(endpoint, cluster, attributeID, mask, manufacturerCode, dataType, data); - return EMBER_ZCL_STATUS_SUCCESS; + // Post write attribute callback for all attributes changes, regardless + // of cluster. + emberAfPostAttributeChangeCallback(endpoint, cluster, attributeID, mask, manufacturerCode, dataType, + emberAfAttributeSize(metadata), data); + + // Post-write attribute callback specific + // to the cluster that the attribute lives in. + emAfClusterAttributeChangedCallback(endpoint, cluster, attributeID, mask, manufacturerCode); + } + else + { + // bug: 11618, we are not handling properly external attributes + // in this case... We need to do something. We don't really + // know if it will succeed. + emberAfAttributesPrintln("WRITE: no write, just a test"); + emberAfAttributesFlush(); + } + + return EMBER_ZCL_STATUS_SUCCESS; } // If dataPtr is NULL, no data is copied to the caller. // readLength should be 0 in that case. -EmberAfStatus emAfReadAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t *dataPtr, - uint16_t readLength, - EmberAfAttributeType *dataType) +EmberAfStatus emAfReadAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * dataPtr, uint16_t readLength, EmberAfAttributeType * dataType) { - EmberAfAttributeMetadata *metadata = NULL; - EmberAfAttributeSearchRecord record; - EmberAfStatus status; - record.endpoint = endpoint; - record.clusterId = cluster; - record.clusterMask = mask; - record.attributeId = attributeID; - record.manufacturerCode = manufacturerCode; - status = emAfReadOrWriteAttribute(&record, - &metadata, - dataPtr, - readLength, - false); // write? - - if (status == EMBER_ZCL_STATUS_SUCCESS) { - // It worked! If the user asked for the type, set it before returning. - if (dataType != NULL) { - (*dataType) = metadata->attributeType; + EmberAfAttributeMetadata * metadata = NULL; + EmberAfAttributeSearchRecord record; + EmberAfStatus status; + record.endpoint = endpoint; + record.clusterId = cluster; + record.clusterMask = mask; + record.attributeId = attributeID; + record.manufacturerCode = manufacturerCode; + status = emAfReadOrWriteAttribute(&record, &metadata, dataPtr, readLength, + false); // write? + + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + // It worked! If the user asked for the type, set it before returning. + if (dataType != NULL) + { + (*dataType) = metadata->attributeType; + } } - } else { // failed, print debug info - if (status == EMBER_ZCL_STATUS_INSUFFICIENT_SPACE) { - emberAfAttributesPrintln("READ: attribute size too large for caller"); - emberAfAttributesFlush(); + else + { // failed, print debug info + if (status == EMBER_ZCL_STATUS_INSUFFICIENT_SPACE) + { + emberAfAttributesPrintln("READ: attribute size too large for caller"); + emberAfAttributesFlush(); + } } - } - return status; + return status; } diff --git a/examples/wifi-echo/server/esp32/main/attribute-table.h b/examples/wifi-echo/server/esp32/main/attribute-table.h index 9943ee6641bc62..0b6927cf50f302 100644 --- a/examples/wifi-echo/server/esp32/main/attribute-table.h +++ b/examples/wifi-echo/server/esp32/main/attribute-table.h @@ -31,12 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains the definitions for the attribute table, its - * sizes, count, and API. + * @brief This file contains the definitions for the + *attribute table, its sizes, count, and API. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef ZCL_UTIL_ATTRIBUTE_TABLE_H #define ZCL_UTIL_ATTRIBUTE_TABLE_H @@ -46,54 +47,25 @@ #define ZCL_NULL_ATTRIBUTE_TABLE_INDEX 0xFFFF // Remote devices writing attributes of local device -EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* dataPtr, +EmberAfStatus emberAfWriteAttributeExternal(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, + uint8_t mask, uint16_t manufacturerCode, uint8_t * dataPtr, EmberAfAttributeType dataType); -void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attrId, - uint8_t mask, - uint16_t manufacturerCode, - uint16_t readLength); -EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint8_t *buffer, - uint8_t bufLen, - uint8_t *bufIndex); +void emberAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, + uint16_t manufacturerCode, uint16_t readLength); +EmberAfStatus emberAfAppendAttributeReportFields(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint8_t * buffer, uint8_t bufLen, uint8_t * bufIndex); void emberAfPrintAttributeTable(void); -bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId startAttributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t maxAttributeIds, +bool emberAfReadSequentialAttributesAddToResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId startAttributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t maxAttributeIds, bool includeAccessControl); -EmberAfStatus emAfWriteAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* data, - EmberAfAttributeType dataType, - bool overrideReadOnlyAndDataType, - bool justTest); +EmberAfStatus emAfWriteAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * data, EmberAfAttributeType dataType, + bool overrideReadOnlyAndDataType, bool justTest); -EmberAfStatus emAfReadAttribute(uint8_t endpoint, - EmberAfClusterId cluster, - EmberAfAttributeId attributeID, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* dataPtr, - uint16_t readLength, - EmberAfAttributeType* dataType); +EmberAfStatus emAfReadAttribute(uint8_t endpoint, EmberAfClusterId cluster, EmberAfAttributeId attributeID, uint8_t mask, + uint16_t manufacturerCode, uint8_t * dataPtr, uint16_t readLength, EmberAfAttributeType * dataType); #endif // ZCL_UTIL_ATTRIBUTE_TABLE_H diff --git a/examples/wifi-echo/server/esp32/main/client-api.h b/examples/wifi-echo/server/esp32/main/client-api.h index e62019e41605b8..4853b0d3fdc9b5 100644 --- a/examples/wifi-echo/server/esp32/main/client-api.h +++ b/examples/wifi-echo/server/esp32/main/client-api.h @@ -31,11 +31,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file * @brief API for generating command buffer. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef __CLIENT_API__ #define __CLIENT_API__ @@ -88,11 +89,7 @@ * copied as is to the destination buffer. The length is not * included. */ -uint16_t emberAfFillExternalBuffer(uint8_t frameControl, - EmberAfClusterId clusterId, - uint8_t commandId, - const char * format, - ...); +uint16_t emberAfFillExternalBuffer(uint8_t frameControl, EmberAfClusterId clusterId, uint8_t commandId, const char * format, ...); /** * @brief Function that fills in the buffer with manufacturer-specific command. @@ -136,12 +133,8 @@ uint16_t emberAfFillExternalBuffer(uint8_t frameControl, * copied as is to the destination buffer. The length is not * included. */ -uint16_t emberAfFillExternalManufacturerSpecificBuffer(uint8_t frameControl, - EmberAfClusterId clusterId, - uint16_t manufacturerCode, - uint8_t commandId, - const char * format, - ...); +uint16_t emberAfFillExternalManufacturerSpecificBuffer(uint8_t frameControl, EmberAfClusterId clusterId, uint16_t manufacturerCode, + uint8_t commandId, const char * format, ...); /** * @brief Function that registers the buffer to use with the fill function. @@ -152,10 +145,7 @@ uint16_t emberAfFillExternalManufacturerSpecificBuffer(uint8_t frameControl, * @param responseLengthPtr Location where length of message will be written into. * @param apsFramePtr Location where APS frame data will be written. */ -void emberAfSetExternalBuffer(uint8_t *buffer, - uint16_t bufferLen, - uint16_t *responseLengthPtr, - EmberApsFrame *apsFramePtr); +void emberAfSetExternalBuffer(uint8_t * buffer, uint16_t bufferLen, uint16_t * responseLengthPtr, EmberApsFrame * apsFramePtr); /** * @brief Stateless function that fills the passed buffer with command data. @@ -164,22 +154,17 @@ void emberAfSetExternalBuffer(uint8_t *buffer, * Used internally by emberAfFillExternalBuffer, but can be used * for generic buffer filling. */ -uint16_t emberAfFillBuffer(uint8_t *buffer, - uint16_t bufferLen, - uint8_t frameControl, - uint8_t commandId, - const char * format, - ...); +uint16_t emberAfFillBuffer(uint8_t * buffer, uint16_t bufferLen, uint8_t frameControl, uint8_t commandId, const char * format, ...); #if !defined(DOXYGEN_SHOULD_SKIP_THIS) // The buffer used for filling ZCL Messages. -extern uint8_t *emAfZclBuffer; +extern uint8_t * emAfZclBuffer; // Max length of the buffer. extern uint16_t emAfZclBufferLen; // Pointer to where this API should put the length. -extern uint16_t *emAfResponseLengthPtr; +extern uint16_t * emAfResponseLengthPtr; // The APS frame accompanying the ZCL message. -extern EmberApsFrame *emAfCommandApsFrame; +extern EmberApsFrame * emAfCommandApsFrame; #endif // Generated macros. diff --git a/examples/wifi-echo/server/esp32/main/common.h b/examples/wifi-echo/server/esp32/main/common.h index 92cd0a8b91049e..b69ef0e5174e94 100644 --- a/examples/wifi-echo/server/esp32/main/common.h +++ b/examples/wifi-echo/server/esp32/main/common.h @@ -31,27 +31,28 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains the includes that are common to all clusters - * in the util. + * @brief This file contains the includes that are + *common to all clusters in the util. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef SILABS_COMMON_H #define SILABS_COMMON_H // App framework #include "af.h" -#include "util.h" -#include "time-util.h" -#include "attribute-table.h" #include "attribute-storage.h" +#include "attribute-table.h" +#include "time-util.h" +#include "util.h" // the variables used to setup and send responses to cluster messages extern EmberApsFrame emberAfResponseApsFrame; -extern uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; +extern uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; extern uint16_t appResponseLength; extern EmberNodeId emberAfResponseDestination; -#endif //SILABS_COMMON_H +#endif // SILABS_COMMON_H diff --git a/examples/wifi-echo/server/esp32/main/config.h b/examples/wifi-echo/server/esp32/main/config.h index 25172346ec5598..5a45e5384b685e 100644 --- a/examples/wifi-echo/server/esp32/main/config.h +++ b/examples/wifi-echo/server/esp32/main/config.h @@ -31,31 +31,39 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** - * @brief This file is the main configuration settings for the Zigbee app. - * The zigbee app can become a Home Automation (HA) device, a Smart - * Energy (SE) device, or a Custom Zigbee device. +/***************************************************************************/ +/** + * @brief This file is the main configuration settings + *for the Zigbee app. The zigbee app can become a Home + *Automation (HA) device, a Smart Energy (SE) device, + *or a Custom Zigbee device. * - * This application can be configured using AppBuilder. AppBuilder - * generates a file containing defines that setup what pieces of the - * code is used (which clusters, security settings, zigbee device type, - * serial port, etc). These defines are added to a new file and included - * by setting ZA_GENERATED_HEADER to the new filename so these defines are - * sourced first. + * This application can be configured using + *AppBuilder. AppBuilder generates a file containing + *defines that setup what pieces of the code is used + *(which clusters, security settings, zigbee device + *type, serial port, etc). These defines are added to + *a new file and included by setting + *ZA_GENERATED_HEADER to the new filename so these + *defines are sourced first. * - * This file also contains default values for the defines so some can - * be set by the user but defaults are always available. + * This file also contains default values for the + *defines so some can be set by the user but defaults + *are always available. ******************************************************************************* * # License - * Copyright 2018 Silicon Laboratories, Inc. www.silabs.com + * Copyright 2018 Silicon Laboratories, Inc. + *www.silabs.com ******************************************************************************* * - * The licensor of this software is Silicon Laboratories Inc. Your use of this - * software is governed by the terms of Silicon Labs Master Software License - * Agreement (MSLA) available at - * www.silabs.com/about-us/legal/master-software-license-agreement. This - * software is distributed to you in Source Code format and is governed by the - * sections of the MSLA applicable to Source Code. + * The licensor of this software is Silicon + *Laboratories Inc. Your use of this software is + *governed by the terms of Silicon Labs Master + *Software License Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. + *This software is distributed to you in Source Code + *format and is governed by the sections of the MSLA + *applicable to Source Code. * ******************************************************************************/ @@ -65,15 +73,15 @@ // include generated configuration information from AppBuilder. // ZA_GENERATED_HEADER is defined in the project file #ifdef ZA_GENERATED_HEADER - #include ZA_GENERATED_HEADER +#include ZA_GENERATED_HEADER #else - #include "gen/gen_config.h" +#include "gen/gen_config.h" #endif #ifdef ATTRIBUTE_STORAGE_CONFIGURATION - #include ATTRIBUTE_STORAGE_CONFIGURATION +#include ATTRIBUTE_STORAGE_CONFIGURATION #else - #include "gen/endpoint_config.h" +#include "gen/endpoint_config.h" #endif #include "gen/gen_tokens.h" // For GENERATED_TOKEN_LOADER/SAVER macros @@ -102,7 +110,7 @@ // ID allocated by the Zigbee alliance. This shall not change. #define EMBER_COMPANY_MANUFACTURER_CODE 0x1002 #ifndef EMBER_AF_MANUFACTURER_CODE - #define EMBER_AF_MANUFACTURER_CODE 0x0000 +#define EMBER_AF_MANUFACTURER_CODE 0x0000 #endif // This file determines the security profile used, and from that various @@ -119,11 +127,11 @@ // the max source route overhead and broadcast radius // if we havent defined MAX_HOPS then define based on profile ID #ifndef ZA_MAX_HOPS - #ifdef EMBER_AF_HAS_SECURITY_PROFILE_SE - #define ZA_MAX_HOPS 6 - #else - #define ZA_MAX_HOPS 12 - #endif +#ifdef EMBER_AF_HAS_SECURITY_PROFILE_SE +#define ZA_MAX_HOPS 6 +#else +#define ZA_MAX_HOPS 12 +#endif #endif #ifndef EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH @@ -134,11 +142,9 @@ // available from emberMaximumApsPayloadLength() or ezspMaximumPayloadLength(). // See http://portal.ember.com/faq/payload for more information. #ifdef EMBER_AF_HAS_SECURITY_PROFILE_NONE - #define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ - 100 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH +#define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH 100 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH #else - #define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ - 82 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH +#define EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH 82 - EMBER_AF_SOURCE_ROUTING_RESERVED_PAYLOAD_LENGTH #endif // Max PHY size = 128 @@ -165,13 +171,12 @@ // as responses. // Maximum payload length. // If fragmenation is enabled, and fragmentation length is bigger than default, then use that -#if defined(EMBER_AF_PLUGIN_FRAGMENTATION) \ - && (EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE > EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH) - #define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE - #define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE +#if defined(EMBER_AF_PLUGIN_FRAGMENTATION) && (EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE > EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH) +#define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE +#define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_PLUGIN_FRAGMENTATION_BUFFER_SIZE #else - #define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH - #define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH +#define EMBER_AF_MAXIMUM_SEND_PAYLOAD_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH +#define EMBER_AF_INCOMING_BUFFER_LENGTH EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH #endif // ******************************************************************* @@ -187,14 +192,14 @@ // Unless we are not using security, our stack profile is 2 (ZigBee Pro). The // stack will set up other configuration values based on profile. #ifndef EMBER_AF_HAS_SECURITY_PROFILE_NONE - #define EMBER_STACK_PROFILE 2 +#define EMBER_STACK_PROFILE 2 #else - #ifndef EMBER_STACK_PROFILE - #define EMBER_STACK_PROFILE 0 - #endif - #ifndef EMBER_SECURITY_LEVEL - #define EMBER_SECURITY_LEVEL 0 - #endif +#ifndef EMBER_STACK_PROFILE +#define EMBER_STACK_PROFILE 0 +#endif +#ifndef EMBER_SECURITY_LEVEL +#define EMBER_SECURITY_LEVEL 0 +#endif #endif // ******************************************************************* @@ -218,7 +223,7 @@ #define EZSP_APPLICATION_HAS_ZIGBEE_KEY_ESTABLISHMENT_HANDLER #ifndef EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE - #define EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE EMBER_APS_UNICAST_MESSAGE_COUNT +#define EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE EMBER_APS_UNICAST_MESSAGE_COUNT #endif // EMBER_AF_MESSAGE_SENT_CALLBACK_TABLE_SIZE #define EMBER_APPLICATION_HAS_COMMAND_ACTION_HANDLER @@ -228,20 +233,20 @@ // // define the serial port that the application uses to be 1 if this is not set -#ifndef HAL_CONFIG //HAL Config handles serial port allocation +#ifndef HAL_CONFIG // HAL Config handles serial port allocation #ifndef APP_SERIAL - #define APP_SERIAL 1 +#define APP_SERIAL 1 +#endif +#ifdef EMBER_TEST +#include "app/util/ezsp/uart-simulation-remap.h" #endif - #ifdef EMBER_TEST - #include "app/util/ezsp/uart-simulation-remap.h" - #endif #endif // The address table plugin is enabled by default. If it gets disabled for some // reason, we still need to define these #defines to some default value. #ifndef EMBER_AF_PLUGIN_ADDRESS_TABLE - #define EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE 2 - #define EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE 2 +#define EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE 2 +#define EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE 2 #endif // The total size of the address table is the size of the section used by the @@ -249,24 +254,18 @@ // The NCP allows each section to be sized independently, but the SOC requires // a single configuration for the whole table. #ifndef EMBER_ADDRESS_TABLE_SIZE - #define EMBER_ADDRESS_TABLE_SIZE \ - (EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE \ - + EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE) +#define EMBER_ADDRESS_TABLE_SIZE (EMBER_AF_PLUGIN_ADDRESS_TABLE_SIZE + EMBER_AF_PLUGIN_ADDRESS_TABLE_TRUST_CENTER_CACHE_SIZE) #endif #ifndef EMBER_AF_DEFAULT_APS_OPTIONS // BUGZID 12261: Concentrators use MTORRs for route discovery and should not // enable route discovery in the APS options. - #ifdef EMBER_AF_PLUGIN_CONCENTRATOR - #define EMBER_AF_DEFAULT_APS_OPTIONS \ - (EMBER_APS_OPTION_RETRY \ - | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) - #else - #define EMBER_AF_DEFAULT_APS_OPTIONS \ - (EMBER_APS_OPTION_RETRY \ - | EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY \ - | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) - #endif +#ifdef EMBER_AF_PLUGIN_CONCENTRATOR +#define EMBER_AF_DEFAULT_APS_OPTIONS (EMBER_APS_OPTION_RETRY | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) +#else +#define EMBER_AF_DEFAULT_APS_OPTIONS \ + (EMBER_APS_OPTION_RETRY | EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY | EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY) +#endif #endif // ******************************************************************* @@ -274,31 +273,31 @@ // // #ifdef EMBER_AF_DEFAULT_RESPONSE_POLICY_NEVER - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS ZCL_DISABLE_DEFAULT_RESPONSE_MASK - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS ZCL_DISABLE_DEFAULT_RESPONSE_MASK +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK #elif defined(EMBER_AF_DEFAULT_RESPONSE_POLICY_CONDITIONAL) - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES ZCL_DISABLE_DEFAULT_RESPONSE_MASK #else - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 - #define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES 0 +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_REQUESTS 0 +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES 0 #endif // EMBER_AF_DEFAULT_RESPONSE_POLICY_NEVER #ifdef EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS - #ifdef EMBER_AF_USE_STANDARD_NETWORK_INIT - #error "Custom options cannot be used with the standard network init" - #endif +#ifdef EMBER_AF_USE_STANDARD_NETWORK_INIT +#error "Custom options cannot be used with the standard network init" +#endif #else - #ifdef EMBER_AF_HAS_SECURITY_PROFILE_Z3 // Z3 Compliant end devices must send a rejoin request on reboot - #define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_END_DEVICE_REJOIN_ON_REBOOT - #else // EMBER_AF_HAS_SECURITY_PROFILE_Z3 - #define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_NO_OPTIONS - #endif // EMBER_AF_HAS_SECURITY_PROFILE_Z3 +#ifdef EMBER_AF_HAS_SECURITY_PROFILE_Z3 // Z3 Compliant end devices must send a rejoin request on reboot +#define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_END_DEVICE_REJOIN_ON_REBOOT +#else // EMBER_AF_HAS_SECURITY_PROFILE_Z3 +#define Z3_NETWORK_INIT_BEHAVIOR EMBER_NETWORK_INIT_NO_OPTIONS +#endif // EMBER_AF_HAS_SECURITY_PROFILE_Z3 // We always want to store our parent info in a token. This prevents doing an // orphan scan upon reboot, which can suffer from the multiple-parent- // responses issue - #define EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS (EMBER_NETWORK_INIT_PARENT_INFO_IN_TOKEN | Z3_NETWORK_INIT_BEHAVIOR) +#define EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS (EMBER_NETWORK_INIT_PARENT_INFO_IN_TOKEN | Z3_NETWORK_INIT_BEHAVIOR) #endif // EMBER_AF_CUSTOM_NETWORK_INIT_OPTIONS #endif // __EMBER_AF_CONFIG_H__ diff --git a/examples/wifi-echo/server/esp32/main/gen/af-structs.h b/examples/wifi-echo/server/esp32/main/gen/af-structs.h index 400e3a410db135..8009281c7692c6 100644 --- a/examples/wifi-echo/server/esp32/main/gen/af-structs.h +++ b/examples/wifi-echo/server/esp32/main/gen/af-structs.h @@ -39,425 +39,420 @@ #ifndef SILABS_EMBER_AF_STRUCTS #define SILABS_EMBER_AF_STRUCTS - // Generated structs from the metadata // Struct for IasAceZoneStatusResult -typedef struct _IasAceZoneStatusResult { - uint8_t zoneId; - uint16_t zoneStatus; +typedef struct _IasAceZoneStatusResult +{ + uint8_t zoneId; + uint16_t zoneStatus; } IasAceZoneStatusResult; - // Struct for ReadAttributeStatusRecord -typedef struct _ReadAttributeStatusRecord { - uint16_t attributeId; - uint8_t status; - uint8_t attributeType; - uint8_t* attributeLocation; +typedef struct _ReadAttributeStatusRecord +{ + uint16_t attributeId; + uint8_t status; + uint8_t attributeType; + uint8_t * attributeLocation; } ReadAttributeStatusRecord; - // Struct for WriteAttributeRecord -typedef struct _WriteAttributeRecord { - uint16_t attributeId; - uint8_t attributeType; - uint8_t* attributeLocation; +typedef struct _WriteAttributeRecord +{ + uint16_t attributeId; + uint8_t attributeType; + uint8_t * attributeLocation; } WriteAttributeRecord; - // Struct for WriteAttributeStatusRecord -typedef struct _WriteAttributeStatusRecord { - uint8_t status; - uint16_t attributeId; +typedef struct _WriteAttributeStatusRecord +{ + uint8_t status; + uint16_t attributeId; } WriteAttributeStatusRecord; - // Struct for ConfigureReportingRecord -typedef struct _ConfigureReportingRecord { - uint8_t direction; - uint16_t attributeId; - uint8_t attributeType; - uint16_t minimumReportingInterval; - uint16_t maximumReportingInterval; - uint8_t* reportableChangeLocation; - uint16_t timeoutPeriod; +typedef struct _ConfigureReportingRecord +{ + uint8_t direction; + uint16_t attributeId; + uint8_t attributeType; + uint16_t minimumReportingInterval; + uint16_t maximumReportingInterval; + uint8_t * reportableChangeLocation; + uint16_t timeoutPeriod; } ConfigureReportingRecord; - // Struct for ConfigureReportingStatusRecord -typedef struct _ConfigureReportingStatusRecord { - uint8_t status; - uint8_t direction; - uint16_t attributeId; +typedef struct _ConfigureReportingStatusRecord +{ + uint8_t status; + uint8_t direction; + uint16_t attributeId; } ConfigureReportingStatusRecord; - // Struct for ReadReportingConfigurationRecord -typedef struct _ReadReportingConfigurationRecord { - uint8_t status; - uint8_t direction; - uint16_t attributeId; - uint8_t attributeType; - uint16_t minimumReportingInterval; - uint16_t maximumReportingInterval; - uint8_t* reportableChangeLocation; - uint16_t timeoutPeriod; +typedef struct _ReadReportingConfigurationRecord +{ + uint8_t status; + uint8_t direction; + uint16_t attributeId; + uint8_t attributeType; + uint16_t minimumReportingInterval; + uint16_t maximumReportingInterval; + uint8_t * reportableChangeLocation; + uint16_t timeoutPeriod; } ReadReportingConfigurationRecord; - // Struct for ReadReportingConfigurationAttributeRecord -typedef struct _ReadReportingConfigurationAttributeRecord { - uint8_t direction; - uint16_t attributeId; +typedef struct _ReadReportingConfigurationAttributeRecord +{ + uint8_t direction; + uint16_t attributeId; } ReadReportingConfigurationAttributeRecord; - // Struct for ReportAttributeRecord -typedef struct _ReportAttributeRecord { - uint16_t attributeId; - uint8_t attributeType; - uint8_t* attributeLocation; +typedef struct _ReportAttributeRecord +{ + uint16_t attributeId; + uint8_t attributeType; + uint8_t * attributeLocation; } ReportAttributeRecord; - // Struct for DiscoverAttributesInfoRecord -typedef struct _DiscoverAttributesInfoRecord { - uint16_t attributeId; - uint8_t attributeType; +typedef struct _DiscoverAttributesInfoRecord +{ + uint16_t attributeId; + uint8_t attributeType; } DiscoverAttributesInfoRecord; - // Struct for ExtendedDiscoverAttributesInfoRecord -typedef struct _ExtendedDiscoverAttributesInfoRecord { - uint16_t attributeId; - uint8_t attributeType; - uint8_t attributeAccessControl; +typedef struct _ExtendedDiscoverAttributesInfoRecord +{ + uint16_t attributeId; + uint8_t attributeType; + uint8_t attributeAccessControl; } ExtendedDiscoverAttributesInfoRecord; - // Struct for ReadStructuredAttributeRecord -typedef struct _ReadStructuredAttributeRecord { - uint16_t attributeId; - uint8_t indicator; - uint16_t indicies; +typedef struct _ReadStructuredAttributeRecord +{ + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; } ReadStructuredAttributeRecord; - // Struct for WriteStructuredAttributeRecord -typedef struct _WriteStructuredAttributeRecord { - uint16_t attributeId; - uint8_t indicator; - uint16_t indicies; - uint8_t attributeType; - uint8_t* attributeLocation; +typedef struct _WriteStructuredAttributeRecord +{ + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; + uint8_t attributeType; + uint8_t * attributeLocation; } WriteStructuredAttributeRecord; - // Struct for WriteStructuredAttributeStatusRecord -typedef struct _WriteStructuredAttributeStatusRecord { - uint8_t status; - uint16_t attributeId; - uint8_t indicator; - uint16_t indicies; +typedef struct _WriteStructuredAttributeStatusRecord +{ + uint8_t status; + uint16_t attributeId; + uint8_t indicator; + uint16_t indicies; } WriteStructuredAttributeStatusRecord; - // Struct for SceneExtensionAttributeInfo -typedef struct _SceneExtensionAttributeInfo { - uint8_t attributeType; - uint8_t* attributeLocation; +typedef struct _SceneExtensionAttributeInfo +{ + uint8_t attributeType; + uint8_t * attributeLocation; } SceneExtensionAttributeInfo; - // Struct for SceneExtensionFieldSet -typedef struct _SceneExtensionFieldSet { - uint16_t clusterId; - uint8_t length; - uint8_t value; +typedef struct _SceneExtensionFieldSet +{ + uint16_t clusterId; + uint8_t length; + uint8_t value; } SceneExtensionFieldSet; - // Struct for BlockThreshold -typedef struct _BlockThreshold { - uint8_t blockThreshold; - uint8_t priceControl; - uint32_t blockPeriodStartTime; - uint32_t blockPeriodDurationMinutes; - uint8_t fuelType; - uint32_t standingCharge; +typedef struct _BlockThreshold +{ + uint8_t blockThreshold; + uint8_t priceControl; + uint32_t blockPeriodStartTime; + uint32_t blockPeriodDurationMinutes; + uint8_t fuelType; + uint32_t standingCharge; } BlockThreshold; - // Struct for Notification -typedef struct _Notification { - uint16_t contentId; - uint8_t statusFeedback; +typedef struct _Notification +{ + uint16_t contentId; + uint8_t statusFeedback; } Notification; - // Struct for NeighborInfo -typedef struct _NeighborInfo { - uint8_t* neighbor; - int16_t x; - int16_t y; - int16_t z; - int8_t rssi; - uint8_t numberRssiMeasurements; +typedef struct _NeighborInfo +{ + uint8_t * neighbor; + int16_t x; + int16_t y; + int16_t z; + int8_t rssi; + uint8_t numberRssiMeasurements; } NeighborInfo; - // Struct for ChatParticipant -typedef struct _ChatParticipant { - uint16_t uid; - uint8_t* nickname; +typedef struct _ChatParticipant +{ + uint16_t uid; + uint8_t * nickname; } ChatParticipant; - // Struct for ChatRoom -typedef struct _ChatRoom { - uint16_t cid; - uint8_t* name; +typedef struct _ChatRoom +{ + uint16_t cid; + uint8_t * name; } ChatRoom; - // Struct for NodeInformation -typedef struct _NodeInformation { - uint16_t uid; - uint16_t address; - uint8_t endpoint; - uint8_t* nickname; +typedef struct _NodeInformation +{ + uint16_t uid; + uint16_t address; + uint8_t endpoint; + uint8_t * nickname; } NodeInformation; - // Struct for ScheduledPhase -typedef struct _ScheduledPhase { - uint8_t energyPhaseId; - uint16_t scheduledTime; +typedef struct _ScheduledPhase +{ + uint8_t energyPhaseId; + uint16_t scheduledTime; } ScheduledPhase; - // Struct for TransferredPhase -typedef struct _TransferredPhase { - uint8_t energyPhaseId; - uint8_t macroPhaseId; - uint16_t expectedDuration; - uint16_t peakPower; - uint16_t energy; - uint16_t maxActivationDelay; +typedef struct _TransferredPhase +{ + uint8_t energyPhaseId; + uint8_t macroPhaseId; + uint16_t expectedDuration; + uint16_t peakPower; + uint16_t energy; + uint16_t maxActivationDelay; } TransferredPhase; - // Struct for PowerProfileRecord -typedef struct _PowerProfileRecord { - uint8_t powerProfileId; - uint8_t energyPhaseId; - uint8_t powerProfileRemoteControl; - uint8_t powerProfileState; +typedef struct _PowerProfileRecord +{ + uint8_t powerProfileId; + uint8_t energyPhaseId; + uint8_t powerProfileRemoteControl; + uint8_t powerProfileState; } PowerProfileRecord; - // Struct for PriceMatrixSubPayload -typedef struct _PriceMatrixSubPayload { - uint8_t tierBlockId; - uint32_t price; +typedef struct _PriceMatrixSubPayload +{ + uint8_t tierBlockId; + uint32_t price; } PriceMatrixSubPayload; - // Struct for BlockThresholdSubPayload -typedef struct _BlockThresholdSubPayload { - uint8_t tierNumberOfBlockThresholds; - uint8_t* blockThreshold; +typedef struct _BlockThresholdSubPayload +{ + uint8_t tierNumberOfBlockThresholds; + uint8_t * blockThreshold; } BlockThresholdSubPayload; - // Struct for TierLabelsPayload -typedef struct _TierLabelsPayload { - uint8_t tierId; - uint8_t* tierLabel; +typedef struct _TierLabelsPayload +{ + uint8_t tierId; + uint8_t * tierLabel; } TierLabelsPayload; - // Void typedef for Signature which is empty. // this will result in all the references to the data being as uint8_t* typedef uint8_t Signature; - // Struct for SnapshotResponsePayload -typedef struct _SnapshotResponsePayload { - uint8_t snapshotScheduleId; - uint8_t snapshotScheduleConfirmation; +typedef struct _SnapshotResponsePayload +{ + uint8_t snapshotScheduleId; + uint8_t snapshotScheduleConfirmation; } SnapshotResponsePayload; - // Struct for SnapshotSchedulePayload -typedef struct _SnapshotSchedulePayload { - uint8_t snapshotScheduleId; - uint32_t snapshotStartTime; - uint32_t snapshotSchedule; - uint8_t snapshotPayloadType; - uint32_t snapshotCause; +typedef struct _SnapshotSchedulePayload +{ + uint8_t snapshotScheduleId; + uint32_t snapshotStartTime; + uint32_t snapshotSchedule; + uint8_t snapshotPayloadType; + uint32_t snapshotCause; } SnapshotSchedulePayload; - // Struct for Protocol -typedef struct _Protocol { - uint16_t manufacturerCode; - uint8_t protocolId; +typedef struct _Protocol +{ + uint16_t manufacturerCode; + uint8_t protocolId; } Protocol; - // Struct for TopUpPayload -typedef struct _TopUpPayload { - uint8_t* topUpCode; - int32_t topUpAmount; - uint32_t topUpTime; +typedef struct _TopUpPayload +{ + uint8_t * topUpCode; + int32_t topUpAmount; + uint32_t topUpTime; } TopUpPayload; - // Struct for DebtPayload -typedef struct _DebtPayload { - uint32_t collectionTime; - uint32_t amountCollected; - uint8_t debtType; - uint32_t outstandingDebt; +typedef struct _DebtPayload +{ + uint32_t collectionTime; + uint32_t amountCollected; + uint8_t debtType; + uint32_t outstandingDebt; } DebtPayload; - // Struct for ScheduleEntry -typedef struct _ScheduleEntry { - uint16_t startTime; - uint8_t activePriceTierOrFriendlyCreditEnable; +typedef struct _ScheduleEntry +{ + uint16_t startTime; + uint8_t activePriceTierOrFriendlyCreditEnable; } ScheduleEntry; - // Struct for ScheduleEntryRateSwitchTimes -typedef struct _ScheduleEntryRateSwitchTimes { - uint16_t startTime; - uint8_t priceTier; +typedef struct _ScheduleEntryRateSwitchTimes +{ + uint16_t startTime; + uint8_t priceTier; } ScheduleEntryRateSwitchTimes; - // Struct for ScheduleEntryFriendlyCreditSwitchTimes -typedef struct _ScheduleEntryFriendlyCreditSwitchTimes { - uint16_t startTime; - uint8_t friendlyCreditEnable; +typedef struct _ScheduleEntryFriendlyCreditSwitchTimes +{ + uint16_t startTime; + uint8_t friendlyCreditEnable; } ScheduleEntryFriendlyCreditSwitchTimes; - // Struct for ScheduleEntryAuxilliaryLoadSwitchTimes -typedef struct _ScheduleEntryAuxilliaryLoadSwitchTimes { - uint16_t startTime; - uint8_t auxiliaryLoadSwitchState; +typedef struct _ScheduleEntryAuxilliaryLoadSwitchTimes +{ + uint16_t startTime; + uint8_t auxiliaryLoadSwitchState; } ScheduleEntryAuxilliaryLoadSwitchTimes; - // Struct for SeasonEntry -typedef struct _SeasonEntry { - uint32_t seasonStartDate; - uint8_t weekIdRef; +typedef struct _SeasonEntry +{ + uint32_t seasonStartDate; + uint8_t weekIdRef; } SeasonEntry; - // Struct for SpecialDay -typedef struct _SpecialDay { - uint32_t specialDayDate; - uint8_t dayIdRef; +typedef struct _SpecialDay +{ + uint32_t specialDayDate; + uint8_t dayIdRef; } SpecialDay; - // Struct for EventConfigurationPayload -typedef struct _EventConfigurationPayload { - uint16_t eventId; - uint8_t eventConfiguration; +typedef struct _EventConfigurationPayload +{ + uint16_t eventId; + uint8_t eventConfiguration; } EventConfigurationPayload; - // Struct for EventLogPayload -typedef struct _EventLogPayload { - uint8_t logId; - uint16_t eventId; - uint32_t eventTime; - uint8_t* eventData; +typedef struct _EventLogPayload +{ + uint8_t logId; + uint16_t eventId; + uint32_t eventTime; + uint8_t * eventData; } EventLogPayload; - // Void typedef for Identity which is empty. // this will result in all the references to the data being as uint8_t* typedef uint8_t Identity; - // Void typedef for EphemeralData which is empty. // this will result in all the references to the data being as uint8_t* typedef uint8_t EphemeralData; - // Void typedef for Smac which is empty. // this will result in all the references to the data being as uint8_t* typedef uint8_t Smac; - // Struct for DeviceInformationRecord -typedef struct _DeviceInformationRecord { - uint8_t* ieeeAddress; - uint8_t endpointId; - uint16_t profileId; - uint16_t deviceId; - uint8_t version; - uint8_t groupIdCount; - uint8_t sort; +typedef struct _DeviceInformationRecord +{ + uint8_t * ieeeAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; + uint8_t groupIdCount; + uint8_t sort; } DeviceInformationRecord; - // Struct for GroupInformationRecord -typedef struct _GroupInformationRecord { - uint16_t groupId; - uint8_t groupType; +typedef struct _GroupInformationRecord +{ + uint16_t groupId; + uint8_t groupType; } GroupInformationRecord; - // Struct for EndpointInformationRecord -typedef struct _EndpointInformationRecord { - uint16_t networkAddress; - uint8_t endpointId; - uint16_t profileId; - uint16_t deviceId; - uint8_t version; +typedef struct _EndpointInformationRecord +{ + uint16_t networkAddress; + uint8_t endpointId; + uint16_t profileId; + uint16_t deviceId; + uint8_t version; } EndpointInformationRecord; - // Struct for GpTranslationTableUpdateTranslation -typedef struct _GpTranslationTableUpdateTranslation { - uint8_t index; - uint8_t gpdCommandId; - uint8_t endpoint; - uint16_t profile; - uint16_t cluster; - uint8_t zigbeeCommandId; - uint8_t* zigbeeCommandPayload; - uint8_t* additionalInfoBlock; +typedef struct _GpTranslationTableUpdateTranslation +{ + uint8_t index; + uint8_t gpdCommandId; + uint8_t endpoint; + uint16_t profile; + uint16_t cluster; + uint8_t zigbeeCommandId; + uint8_t * zigbeeCommandPayload; + uint8_t * additionalInfoBlock; } GpTranslationTableUpdateTranslation; - // Struct for GpPairingConfigurationGroupList -typedef struct _GpPairingConfigurationGroupList { - uint16_t SinkGroup; - uint16_t Alias; +typedef struct _GpPairingConfigurationGroupList +{ + uint16_t SinkGroup; + uint16_t Alias; } GpPairingConfigurationGroupList; - // Struct for WwahBeaconSurvey -typedef struct _WwahBeaconSurvey { - uint16_t deviceShort; - uint8_t rssi; - uint8_t classificationMask; +typedef struct _WwahBeaconSurvey +{ + uint16_t deviceShort; + uint8_t rssi; + uint8_t classificationMask; } WwahBeaconSurvey; - // Struct for WwahClusterStatusToUseTC -typedef struct _WwahClusterStatusToUseTC { - uint16_t clusterId; - uint8_t status; +typedef struct _WwahClusterStatusToUseTC +{ + uint16_t clusterId; + uint8_t status; } WwahClusterStatusToUseTC; - #endif // SILABS_EMBER_AF_STRUCTS diff --git a/examples/wifi-echo/server/esp32/main/gen/att-storage.h b/examples/wifi-echo/server/esp32/main/gen/att-storage.h index e67c5f5053982b..40a1a0088b4872 100644 --- a/examples/wifi-echo/server/esp32/main/gen/att-storage.h +++ b/examples/wifi-echo/server/esp32/main/gen/att-storage.h @@ -39,8 +39,6 @@ #ifndef SILABS_ATTRIBUTE_STORAGE_GEN #define SILABS_ATTRIBUTE_STORAGE_GEN - - // Attribute masks modify how attributes are used by the framework // Attribute that has this mask is NOT read-only #define ATTRIBUTE_MASK_WRITABLE (0x01) @@ -57,7 +55,6 @@ // Attribute is a client attribute #define ATTRIBUTE_MASK_CLIENT (0x40) - // Cluster masks modify how clusters are used by the framework // Does this cluster have init function? #define CLUSTER_MASK_INIT_FUNCTION (0x01) @@ -76,7 +73,6 @@ // Cluster is a client #define CLUSTER_MASK_CLIENT (0x80) - // Command masks modify meanings of commands // Is sending of this client command supported #define COMMAND_MASK_OUTGOING_CLIENT (0x01) diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-id.h b/examples/wifi-echo/server/esp32/main/gen/attribute-id.h index 674c982bfc4d6f..442f72e97e2232 100644 --- a/examples/wifi-echo/server/esp32/main/gen/attribute-id.h +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-id.h @@ -39,7 +39,6 @@ #ifndef SILABS_EMBER_AF_ATTRIBUTE_ID #define SILABS_EMBER_AF_ATTRIBUTE_ID - // Attribute types for cluster: Basic // Cluster specification level: zcl-7.0-07-5123-07 @@ -48,29 +47,28 @@ #define ZCL_BASIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_VERSION_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_APPLICATION_VERSION_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_STACK_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_HW_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_MANUFACTURER_NAME_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_MODEL_IDENTIFIER_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_DATE_CODE_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_POWER_SOURCE_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_GENERIC_DEVICE_CLASS_ATTRIBUTE_ID 0x0008 // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_GENERIC_DEVICE_TYPE_ATTRIBUTE_ID 0x0009 // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_PRODUCT_CODE_ATTRIBUTE_ID 0x000A // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_PRODUCT_URL_ATTRIBUTE_ID 0x000B // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_LOCATION_DESCRIPTION_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_PHYSICAL_ENVIRONMENT_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_DEVICE_ENABLED_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_ALARM_MASK_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_DISABLE_LOCAL_CONFIG_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_CURRENT_LOCALE_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_SW_BUILD_ID_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_VERSION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_APPLICATION_VERSION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_STACK_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HW_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MANUFACTURER_NAME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MODEL_IDENTIFIER_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_DATE_CODE_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_POWER_SOURCE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_GENERIC_DEVICE_CLASS_ATTRIBUTE_ID 0x0008 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_GENERIC_DEVICE_TYPE_ATTRIBUTE_ID 0x0009 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_PRODUCT_CODE_ATTRIBUTE_ID 0x000A // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_PRODUCT_URL_ATTRIBUTE_ID 0x000B // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_LOCATION_DESCRIPTION_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PHYSICAL_ENVIRONMENT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_DEVICE_ENABLED_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_ALARM_MASK_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_DISABLE_LOCAL_CONFIG_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_CURRENT_LOCALE_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_SW_BUILD_ID_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 #define ZCL_BASIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BASIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Power Configuration // Cluster specification level: zcl-7.0-07-5123-07 @@ -79,67 +77,66 @@ #define ZCL_POWER_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MAINS_VOLTAGE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MAINS_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MAINS_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_MAINS_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_MAINS_VOLTAGE_MAX_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_MAINS_VOLTAGE_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_BATTERY_VOLTAGE_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_BATTERY_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_MANUFACTURER_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_BATTERY_SIZE_ATTRIBUTE_ID 0x0031 // Ver.: always -#define ZCL_BATTERY_AHR_RATING_ATTRIBUTE_ID 0x0032 // Ver.: always -#define ZCL_BATTERY_QUANTITY_ATTRIBUTE_ID 0x0033 // Ver.: always -#define ZCL_BATTERY_RATED_VOLTAGE_ATTRIBUTE_ID 0x0034 // Ver.: always -#define ZCL_BATTERY_ALARM_MASK_ATTRIBUTE_ID 0x0035 // Ver.: always -#define ZCL_BATTERY_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0036 // Ver.: always -#define ZCL_BATTERY_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0037 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0038 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0039 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x003A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x003B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x003C // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x003D // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_ALARM_STATE_ATTRIBUTE_ID 0x003E // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_VOLTAGE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_MANUFACTURER_ATTRIBUTE_ID 0x0050 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_SIZE_ATTRIBUTE_ID 0x0051 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_AHR_RATING_ATTRIBUTE_ID 0x0052 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_QUANTITY_ATTRIBUTE_ID 0x0053 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_RATED_VOLTAGE_ATTRIBUTE_ID 0x0054 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_ALARM_MASK_ATTRIBUTE_ID 0x0055 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0056 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0057 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0058 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0059 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x005A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x005B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x005C // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x005D // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_2_ALARM_STATE_ATTRIBUTE_ID 0x005E // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_VOLTAGE_ATTRIBUTE_ID 0x0060 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0061 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_MANUFACTURER_ATTRIBUTE_ID 0x0070 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_SIZE_ATTRIBUTE_ID 0x0071 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_AHR_RATING_ATTRIBUTE_ID 0x0072 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_QUANTITY_ATTRIBUTE_ID 0x0073 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_RATED_VOLTAGE_ATTRIBUTE_ID 0x0074 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_ALARM_MASK_ATTRIBUTE_ID 0x0075 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0076 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0077 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0078 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0079 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x007A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x007B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x007C // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x007D // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BATTERY_3_ALARM_STATE_ATTRIBUTE_ID 0x007E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MAINS_VOLTAGE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAINS_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAINS_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_MAINS_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_MAINS_VOLTAGE_MAX_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_MAINS_VOLTAGE_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_BATTERY_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_MANUFACTURER_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_BATTERY_SIZE_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_BATTERY_AHR_RATING_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_BATTERY_QUANTITY_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_BATTERY_RATED_VOLTAGE_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_BATTERY_ALARM_MASK_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0037 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0038 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0039 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x003A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x003B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x003C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x003D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_ALARM_STATE_ATTRIBUTE_ID 0x003E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_MANUFACTURER_ATTRIBUTE_ID 0x0050 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_SIZE_ATTRIBUTE_ID 0x0051 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_AHR_RATING_ATTRIBUTE_ID 0x0052 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_QUANTITY_ATTRIBUTE_ID 0x0053 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_RATED_VOLTAGE_ATTRIBUTE_ID 0x0054 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_ALARM_MASK_ATTRIBUTE_ID 0x0055 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0056 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0057 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0058 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0059 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x005A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x005B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x005C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x005D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_2_ALARM_STATE_ATTRIBUTE_ID 0x005E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_ATTRIBUTE_ID 0x0060 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_REMAINING_ATTRIBUTE_ID 0x0061 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_MANUFACTURER_ATTRIBUTE_ID 0x0070 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_SIZE_ATTRIBUTE_ID 0x0071 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_AHR_RATING_ATTRIBUTE_ID 0x0072 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_QUANTITY_ATTRIBUTE_ID 0x0073 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_RATED_VOLTAGE_ATTRIBUTE_ID 0x0074 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_ALARM_MASK_ATTRIBUTE_ID 0x0075 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x0076 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x0077 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x0078 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_VOLTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x0079 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_MIN_THRESHOLD_ATTRIBUTE_ID 0x007A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_1_ATTRIBUTE_ID 0x007B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_2_ATTRIBUTE_ID 0x007C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_PERCENTAGE_THRESHOLD_3_ATTRIBUTE_ID 0x007D // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BATTERY_3_ALARM_STATE_ATTRIBUTE_ID 0x007E // Ver.: since ha-1.2-05-3520-29 #define ZCL_POWER_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_POWER_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Device Temperature Configuration // Cluster specification level: zcl-7.0-07-5123-07 @@ -148,19 +145,18 @@ #define ZCL_DEVICE_TEMP_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CURRENT_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MIN_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MAX_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_OVER_TEMP_TOTAL_DWELL_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DEVICE_TEMP_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_LOW_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_HIGH_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_LOW_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_HIGH_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_CURRENT_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MIN_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAX_TEMP_EXPERIENCED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OVER_TEMP_TOTAL_DWELL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DEVICE_TEMP_ALARM_MASK_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_LOW_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_HIGH_TEMP_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_LOW_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_HIGH_TEMP_DWELL_TRIP_POINT_ATTRIBUTE_ID 0x0014 // Ver.: always #define ZCL_DEVICE_TEMP_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DEVICE_TEMP_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Identify // Cluster specification level: zcl-7.0-07-5123-07 @@ -169,12 +165,11 @@ #define ZCL_IDENTIFY_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_IDENTIFY_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_COMMISSION_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_IDENTIFY_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COMMISSION_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always #define ZCL_IDENTIFY_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_IDENTIFY_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Groups // Cluster specification level: zcl-7.0-07-5123-07 @@ -183,11 +178,10 @@ #define ZCL_GROUPS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_GROUP_NAME_SUPPORT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_GROUP_NAME_SUPPORT_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_GROUPS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_GROUPS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Scenes // Cluster specification level: zcl-7.0-07-5123-07 @@ -196,16 +190,15 @@ #define ZCL_SCENES_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SCENE_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CURRENT_SCENE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CURRENT_GROUP_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SCENE_VALID_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SCENE_NAME_SUPPORT_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_LAST_CONFIGURED_BY_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_SCENE_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_SCENE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_GROUP_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SCENE_VALID_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SCENE_NAME_SUPPORT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_LAST_CONFIGURED_BY_ATTRIBUTE_ID 0x0005 // Ver.: always #define ZCL_SCENES_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SCENES_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: On/off // Cluster specification level: zcl-7.0-07-5123-07 @@ -214,19 +207,18 @@ #define ZCL_ON_OFF_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ON_OFF_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_2_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_3_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_4_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ON_TIME_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_OFF_WAIT_TIME_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_START_UP_ON_OFF_ATTRIBUTE_ID 0x4003 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_ON_OFF_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_2_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_3_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAMPLE_MFG_SPECIFIC_TRANSITION_TIME_4_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_TIME_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_OFF_WAIT_TIME_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_START_UP_ON_OFF_ATTRIBUTE_ID 0x4003 // Ver.: since l&o-1.0-15-0014-04 #define ZCL_ON_OFF_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ON_OFF_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: On/off Switch Configuration // Cluster specification level: zcl-7.0-07-5123-07 @@ -235,12 +227,11 @@ #define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SWITCH_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SWITCH_ACTIONS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SWITCH_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SWITCH_ACTIONS_ATTRIBUTE_ID 0x0010 // Ver.: always #define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Level Control // Cluster specification level: zcl-7.0-07-5123-07 @@ -249,19 +240,18 @@ #define ZCL_LEVEL_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CURRENT_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LEVEL_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_ON_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_ON_TRANSITION_TIME_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_DEFAULT_MOVE_RATE_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_START_UP_CURRENT_LEVEL_ATTRIBUTE_ID 0x4000 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_CURRENT_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LEVEL_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ON_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_ON_TRANSITION_TIME_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OFF_TRANSITION_TIME_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DEFAULT_MOVE_RATE_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_START_UP_CURRENT_LEVEL_ATTRIBUTE_ID 0x4000 // Ver.: since l&o-1.0-15-0014-04 #define ZCL_LEVEL_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_LEVEL_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Alarms // Cluster specification level: zcl-7.0-07-5123-07 @@ -270,11 +260,10 @@ #define ZCL_ALARM_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ALARM_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ALARM_COUNT_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_ALARM_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ALARM_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Time // Cluster specification level: zcl-7.0-07-5123-07 @@ -283,20 +272,19 @@ #define ZCL_TIME_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TIME_STATUS_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TIME_ZONE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_DST_START_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DST_END_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_DST_SHIFT_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_STANDARD_TIME_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_LOCAL_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_LAST_SET_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_VALID_UNTIL_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TIME_STATUS_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TIME_ZONE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DST_START_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DST_END_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DST_SHIFT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_STANDARD_TIME_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_LOCAL_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_LAST_SET_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_VALID_UNTIL_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always #define ZCL_TIME_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_TIME_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: RSSI Location // Cluster specification level: zcl-7.0-07-5123-07 @@ -305,23 +293,22 @@ #define ZCL_RSSI_LOCATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LOCATION_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LOCATION_METHOD_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_LOCATION_AGE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_QUALITY_MEASURE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_NUMBER_OF_DEVICES_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_COORDINATE1_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_COORDINATE2_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_COORDINATE3_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_POWER_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_PATH_LOSS_EXPONENT_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_REPORTING_PERIOD_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_CALCULATION_PERIOD_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_NUMBER_RSSI_MEASUREMENTS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_LOCATION_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOCATION_METHOD_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LOCATION_AGE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_QUALITY_MEASURE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_DEVICES_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_COORDINATE1_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COORDINATE2_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_COORDINATE3_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_POWER_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PATH_LOSS_EXPONENT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_REPORTING_PERIOD_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_CALCULATION_PERIOD_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_NUMBER_RSSI_MEASUREMENTS_ATTRIBUTE_ID 0x0017 // Ver.: always #define ZCL_RSSI_LOCATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_RSSI_LOCATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Binary Input (Basic) // Cluster specification level: zcl-7.0-07-5123-07 @@ -330,19 +317,18 @@ #define ZCL_BINARY_INPUT_BASIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ACTIVE_TEXT_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_DESCRIPTION_ATTRIBUTE_ID 0x001C // Ver.: always -#define ZCL_INACTIVE_TEXT_ATTRIBUTE_ID 0x002E // Ver.: always -#define ZCL_OUT_OF_SERVICE_ATTRIBUTE_ID 0x0051 // Ver.: always -#define ZCL_POLARITY_ATTRIBUTE_ID 0x0054 // Ver.: always -#define ZCL_PRESENT_VALUE_ATTRIBUTE_ID 0x0055 // Ver.: always -#define ZCL_RELIABILITY_ATTRIBUTE_ID 0x0067 // Ver.: always -#define ZCL_STATUS_FLAGS_ATTRIBUTE_ID 0x006F // Ver.: always -#define ZCL_APPLICATION_TYPE_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_ACTIVE_TEXT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DESCRIPTION_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_INACTIVE_TEXT_ATTRIBUTE_ID 0x002E // Ver.: always +#define ZCL_OUT_OF_SERVICE_ATTRIBUTE_ID 0x0051 // Ver.: always +#define ZCL_POLARITY_ATTRIBUTE_ID 0x0054 // Ver.: always +#define ZCL_PRESENT_VALUE_ATTRIBUTE_ID 0x0055 // Ver.: always +#define ZCL_RELIABILITY_ATTRIBUTE_ID 0x0067 // Ver.: always +#define ZCL_STATUS_FLAGS_ATTRIBUTE_ID 0x006F // Ver.: always +#define ZCL_APPLICATION_TYPE_ATTRIBUTE_ID 0x0100 // Ver.: always #define ZCL_BINARY_INPUT_BASIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BINARY_INPUT_BASIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Commissioning // Cluster specification level: zcl-7.0-07-5123-07 @@ -351,34 +337,33 @@ #define ZCL_COMMISSIONING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SHORT_ADDRESS_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_EXTENDED_PAN_ID_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_PAN_ID_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_PROTOCOL_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_STACK_PROFILE_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_STARTUP_CONTROL_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_TRUST_CENTER_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_TRUST_CENTER_MASTER_KEY_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_NETWORK_KEY_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_USE_INSECURE_JOIN_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_PRECONFIGURED_LINK_KEY_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_NETWORK_KEY_SEQUENCE_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_NETWORK_KEY_TYPE_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_NETWORK_MANAGER_ADDRESS_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_SCAN_ATTEMPTS_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_TIME_BETWEEN_SCANS_ATTRIBUTE_ID 0x0021 // Ver.: always -#define ZCL_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0022 // Ver.: always -#define ZCL_MAX_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0023 // Ver.: always -#define ZCL_INDIRECT_POLL_RATE_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_PARENT_RETRY_THRESHOLD_ATTRIBUTE_ID 0x0031 // Ver.: always -#define ZCL_CONCENTRATOR_FLAG_ATTRIBUTE_ID 0x0040 // Ver.: always -#define ZCL_CONCENTRATOR_RADIUS_ATTRIBUTE_ID 0x0041 // Ver.: always -#define ZCL_CONCENTRATOR_DISCOVERY_TIME_ATTRIBUTE_ID 0x0042 // Ver.: always +#define ZCL_SHORT_ADDRESS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_EXTENDED_PAN_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PAN_ID_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PROTOCOL_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_STACK_PROFILE_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_STARTUP_CONTROL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_TRUST_CENTER_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_TRUST_CENTER_MASTER_KEY_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_NETWORK_KEY_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_USE_INSECURE_JOIN_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PRECONFIGURED_LINK_KEY_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_NETWORK_KEY_SEQUENCE_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_NETWORK_KEY_TYPE_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_NETWORK_MANAGER_ADDRESS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_SCAN_ATTEMPTS_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_TIME_BETWEEN_SCANS_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_MAX_REJOIN_INTERVAL_ATTRIBUTE_ID 0x0023 // Ver.: always +#define ZCL_INDIRECT_POLL_RATE_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_PARENT_RETRY_THRESHOLD_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_CONCENTRATOR_FLAG_ATTRIBUTE_ID 0x0040 // Ver.: always +#define ZCL_CONCENTRATOR_RADIUS_ATTRIBUTE_ID 0x0041 // Ver.: always +#define ZCL_CONCENTRATOR_DISCOVERY_TIME_ATTRIBUTE_ID 0x0042 // Ver.: always #define ZCL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_COMMISSIONING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Partition // Cluster specification level: zcl-7.0-07-5123-07 @@ -387,37 +372,36 @@ #define ZCL_PARTITION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PARTITION_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_PARTITION_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_PARTIONED_FRAME_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_LARGE_FRAME_SIZE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_NUMBER_OF_ACK_FRAME_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_NACK_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_INTERFRAME_DELAY_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_NUMBER_OF_SEND_RETRIES_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_SENDER_TIMEOUT_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_RECEIVER_TIMEOUT_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_PARTITION_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PARTITION_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PARTIONED_FRAME_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_LARGE_FRAME_SIZE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_ACK_FRAME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_NACK_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_INTERFRAME_DELAY_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_NUMBER_OF_SEND_RETRIES_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_SENDER_TIMEOUT_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_RECEIVER_TIMEOUT_ATTRIBUTE_ID 0x0009 // Ver.: always #define ZCL_PARTITION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_PARTITION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Over the Air Bootloading // Cluster specification level: zcl-7.0-07-5123-07 // Client attributes -#define ZCL_UPGRADE_SERVER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FILE_OFFSET_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CURRENT_FILE_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CURRENT_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DOWNLOADED_FILE_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_DOWNLOADED_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_IMAGE_UPGRADE_STATUS_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_MANUFACTURER_ID_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_IMAGE_TYPE_ID_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_MINIMUM_BLOCK_REQUEST_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_IMAGE_STAMP_ATTRIBUTE_ID 0x000A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_UPGRADE_ACTIVATION_POLICY_ATTRIBUTE_ID 0x000B // Ver.: since se-1.2b-15-0131-02 -#define ZCL_UPGRADE_TIMEOUT_POLICY_ATTRIBUTE_ID 0x000C // Ver.: since se-1.2b-15-0131-02 +#define ZCL_UPGRADE_SERVER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FILE_OFFSET_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_FILE_VERSION_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DOWNLOADED_FILE_VERSION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DOWNLOADED_ZIGBEE_STACK_VERSION_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_IMAGE_UPGRADE_STATUS_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_MANUFACTURER_ID_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_IMAGE_TYPE_ID_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_MINIMUM_BLOCK_REQUEST_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_IMAGE_STAMP_ATTRIBUTE_ID 0x000A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UPGRADE_ACTIVATION_POLICY_ATTRIBUTE_ID 0x000B // Ver.: since se-1.2b-15-0131-02 +#define ZCL_UPGRADE_TIMEOUT_POLICY_ATTRIBUTE_ID 0x000C // Ver.: since se-1.2b-15-0131-02 #define ZCL_OTA_BOOTLOAD_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OTA_BOOTLOAD_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 @@ -425,7 +409,6 @@ #define ZCL_OTA_BOOTLOAD_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OTA_BOOTLOAD_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Power Profile // Cluster specification level: zcl-7.0-07-5123-07 @@ -434,15 +417,14 @@ #define ZCL_POWER_PROFILE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TOTAL_PROFILE_NUM_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MULTIPLE_SCHEDULING_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ENERGY_FORMATTING_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ENERGY_REMOTE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SCHEDULE_MODE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_TOTAL_PROFILE_NUM_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MULTIPLE_SCHEDULING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ENERGY_FORMATTING_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ENERGY_REMOTE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SCHEDULE_MODE_ATTRIBUTE_ID 0x0004 // Ver.: always #define ZCL_POWER_PROFILE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_POWER_PROFILE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Appliance Control // Cluster specification level: zcl-7.0-07-5123-07 @@ -451,13 +433,12 @@ #define ZCL_APPLIANCE_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_START_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FINISH_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_START_TIME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FINISH_TIME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always #define ZCL_APPLIANCE_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_APPLIANCE_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Poll Control // Cluster specification level: zcl-7.0-07-5123-07 @@ -466,51 +447,49 @@ #define ZCL_POLL_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CHECK_IN_INTERVAL_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LONG_POLL_INTERVAL_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SHORT_POLL_INTERVAL_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_FAST_POLL_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CHECK_IN_INTERVAL_MIN_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_LONG_POLL_INTERVAL_MIN_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_FAST_POLL_TIMEOUT_MAX_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_CHECK_IN_INTERVAL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LONG_POLL_INTERVAL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SHORT_POLL_INTERVAL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FAST_POLL_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHECK_IN_INTERVAL_MIN_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_LONG_POLL_INTERVAL_MIN_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_FAST_POLL_TIMEOUT_MAX_ATTRIBUTE_ID 0x0006 // Ver.: always #define ZCL_POLL_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_POLL_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Green Power // Cluster specification level: gp-1.0a-09-5499-26 // Client attributes -#define ZCL_GP_CLIENT_GPP_MAX_PROXY_TABLE_ENTRIES_ATTRIBUTE_ID 0x0010 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_PROXY_TABLE_ATTRIBUTE_ID 0x0011 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_NUMBER_ATTRIBUTE_ID 0x0012 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_TIMER_ATTRIBUTE_ID 0x0013 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_MAX_SEARCH_COUNTER_ATTRIBUTE_ID 0x0014 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_BLOCKED_GPD_ID_ATTRIBUTE_ID 0x0015 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_FUNCTIONALITY_ATTRIBUTE_ID 0x0016 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GPP_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0017 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_CLIENT_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_MAX_PROXY_TABLE_ENTRIES_ATTRIBUTE_ID 0x0010 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_PROXY_TABLE_ATTRIBUTE_ID 0x0011 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_NUMBER_ATTRIBUTE_ID 0x0012 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_NOTIFICATION_RETRY_TIMER_ATTRIBUTE_ID 0x0013 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_MAX_SEARCH_COUNTER_ATTRIBUTE_ID 0x0014 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_BLOCKED_GPD_ID_ATTRIBUTE_ID 0x0015 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_FUNCTIONALITY_ATTRIBUTE_ID 0x0016 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GPP_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0017 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_CLIENT_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 #define ZCL_GREEN_POWER_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_GREEN_POWER_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_GP_SERVER_GPS_MAX_SINK_TABLE_ENTRIES_ATTRIBUTE_ID 0x0000 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_SINK_TABLE_ATTRIBUTE_ID 0x0001 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_COMMUNICATION_MODE_ATTRIBUTE_ID 0x0002 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_COMMISSIONING_EXIT_MODE_ATTRIBUTE_ID 0x0003 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_COMMISSIONING_WINDOW_ATTRIBUTE_ID 0x0004 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_SECURITY_LEVEL_ATTRIBUTE_ID 0x0005 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_FUNCTIONALITY_ATTRIBUTE_ID 0x0006 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GPS_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0007 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SERVER_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_MAX_SINK_TABLE_ENTRIES_ATTRIBUTE_ID 0x0000 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_SINK_TABLE_ATTRIBUTE_ID 0x0001 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMUNICATION_MODE_ATTRIBUTE_ID 0x0002 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMISSIONING_EXIT_MODE_ATTRIBUTE_ID 0x0003 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_COMMISSIONING_WINDOW_ATTRIBUTE_ID 0x0004 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_SECURITY_LEVEL_ATTRIBUTE_ID 0x0005 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_FUNCTIONALITY_ATTRIBUTE_ID 0x0006 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GPS_ACTIVE_FUNCTIONALITY_ATTRIBUTE_ID 0x0007 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_TYPE_ATTRIBUTE_ID 0x0020 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_SHARED_SECURITY_KEY_ATTRIBUTE_ID 0x0021 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SERVER_GP_LINK_KEY_ATTRIBUTE_ID 0x0022 // Ver.: since gp-1.0-09-5499-24 #define ZCL_GREEN_POWER_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_GREEN_POWER_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Keep-Alive // Cluster specification level: se-1.2b-15-0131-02 @@ -519,12 +498,11 @@ #define ZCL_KEEPALIVE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_KEEPALIVE_BASE_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2b-15-0131-02 -#define ZCL_KEEPALIVE_JITTER_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2b-15-0131-02 +#define ZCL_KEEPALIVE_BASE_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2b-15-0131-02 +#define ZCL_KEEPALIVE_JITTER_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2b-15-0131-02 #define ZCL_KEEPALIVE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_KEEPALIVE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Shade Configuration // Cluster specification level: zcl-6.0-15-02018-001 @@ -533,15 +511,14 @@ #define ZCL_SHADE_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SHADE_CONFIG_PHYSICAL_CLOSED_LIMIT_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SHADE_CONFIG_MOTOR_STEP_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SHADE_CONFIG_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SHADE_CONFIG_CLOSED_LIMIT_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_SHADE_CONFIG_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SHADE_CONFIG_PHYSICAL_CLOSED_LIMIT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SHADE_CONFIG_MOTOR_STEP_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SHADE_CONFIG_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SHADE_CONFIG_CLOSED_LIMIT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SHADE_CONFIG_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always #define ZCL_SHADE_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SHADE_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Door Lock // Cluster specification level: zcl-6.0-15-02018-001 @@ -550,53 +527,52 @@ #define ZCL_DOOR_LOCK_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LOCK_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LOCK_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ACTUATOR_ENABLED_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_DOOR_STATE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DOOR_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_DOOR_CLOSED_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_OPEN_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_NUM_LOCK_RECORDS_SUPPORTED_ATTRIBUTE_ID 0x0010 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID 0x0011 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_PIN_USERS_SUPPORTED_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_RFID_USERS_SUPPORTED_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_WEEKDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_YEARDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0015 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUM_HOLIDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0016 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_MAX_PIN_LENGTH_ATTRIBUTE_ID 0x0017 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_MIN_PIN_LENGTH_ATTRIBUTE_ID 0x0018 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_MAX_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x0019 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_MIN_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x001A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ENABLE_LOGGING_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_LANGUAGE_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_LED_SETTINGS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AUTO_RELOCK_TIME_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SOUND_VOLUME_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_OPERATING_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID 0x0026 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID 0x0027 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID 0x0028 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ENABLE_INSIDE_STATUS_LED_ATTRIBUTE_ID 0x002A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID 0x002B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SEND_PIN_OVER_THE_AIR_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_REQUIRE_PIN_FOR_RF_OPERATION_ATTRIBUTE_ID 0x0033 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_ZIGBEE_SECURITY_LEVEL_ATTRIBUTE_ID 0x0034 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_DOOR_LOCK_ALARM_MASK_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_KEYPAD_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_RF_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_MANUAL_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_RFID_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_KEYPAD_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_RF_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_RFID_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCK_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOCK_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ACTUATOR_ENABLED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DOOR_STATE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DOOR_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DOOR_CLOSED_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_OPEN_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_NUM_LOCK_RECORDS_SUPPORTED_ATTRIBUTE_ID 0x0010 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID 0x0011 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_PIN_USERS_SUPPORTED_ATTRIBUTE_ID 0x0012 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_RFID_USERS_SUPPORTED_ATTRIBUTE_ID 0x0013 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_WEEKDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0014 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_YEARDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0015 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUM_HOLIDAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID 0x0016 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MAX_PIN_LENGTH_ATTRIBUTE_ID 0x0017 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MIN_PIN_LENGTH_ATTRIBUTE_ID 0x0018 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MAX_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x0019 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MIN_RFID_CODE_LENGTH_ATTRIBUTE_ID 0x001A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_LOGGING_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LANGUAGE_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LED_SETTINGS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AUTO_RELOCK_TIME_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SOUND_VOLUME_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OPERATING_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID 0x0026 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID 0x0027 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID 0x0028 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_INSIDE_STATUS_LED_ATTRIBUTE_ID 0x002A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID 0x002B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SEND_PIN_OVER_THE_AIR_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_REQUIRE_PIN_FOR_RF_OPERATION_ATTRIBUTE_ID 0x0033 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_ZIGBEE_SECURITY_LEVEL_ATTRIBUTE_ID 0x0034 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_DOOR_LOCK_ALARM_MASK_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_KEYPAD_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RF_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_MANUAL_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RFID_OPERATION_EVENT_MASK_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_KEYPAD_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RF_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RFID_PROGRAMMING_EVENT_MASK_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 #define ZCL_DOOR_LOCK_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DOOR_LOCK_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Window Covering // Cluster specification level: zcl-6.0-15-02018-001 @@ -605,30 +581,29 @@ #define ZCL_WINDOW_COVERING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_COVERING_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LIMIT_LIFT_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_LIMIT_TILT_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CURRENT_LIFT_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CURRENT_TILT_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_NUMBER_LIFT_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_NUMBER_TILT_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_CONFIG_STATUS_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_CURRENT_LIFT_PERCENTAGE_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_CURRENT_TILT_PERCENTAGE_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_OPEN_LIMIT_LIFT_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_OPEN_LIMIT_TILT_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_VELOCITY_LIFT_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_ACCELERATION_LIFT_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_DECELERATION_LIFT_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_MODE_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_SETPOINTS_LIFT_ATTRIBUTE_ID 0x0018 // Ver.: always -#define ZCL_SETPOINTS_TILT_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_COVERING_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LIMIT_LIFT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LIMIT_TILT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_LIFT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CURRENT_TILT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_NUMBER_LIFT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_NUMBER_TILT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_CONFIG_STATUS_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_CURRENT_LIFT_PERCENTAGE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_CURRENT_TILT_PERCENTAGE_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_OPEN_LIMIT_LIFT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_OPEN_LIMIT_TILT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_VELOCITY_LIFT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_ACCELERATION_LIFT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_DECELERATION_LIFT_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MODE_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_SETPOINTS_LIFT_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_SETPOINTS_TILT_ATTRIBUTE_ID 0x0019 // Ver.: always #define ZCL_WINDOW_COVERING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_WINDOW_COVERING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Barrier Control // Cluster specification level: zcl-6.0-15-02018-001 @@ -637,20 +612,19 @@ #define ZCL_BARRIER_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_BARRIER_MOVING_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BARRIER_SAFETY_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_BARRIER_CAPABILITIES_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_BARRIER_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_BARRIER_OPEN_PERIOD_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_BARRIER_POSITION_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_BARRIER_MOVING_STATE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BARRIER_SAFETY_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BARRIER_CAPABILITIES_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BARRIER_OPEN_EVENTS_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_BARRIER_OPEN_PERIOD_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_BARRIER_POSITION_ATTRIBUTE_ID 0x000A // Ver.: always #define ZCL_BARRIER_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BARRIER_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Pump Configuration and Control // Cluster specification level: zcl-6.0-15-02018-001 @@ -659,34 +633,33 @@ #define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MAX_PRESSURE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MAX_SPEED_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MAX_FLOW_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_MIN_CONST_PRESSURE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_MAX_CONST_PRESSURE_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_MIN_COMP_PRESSURE_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_MAX_COMP_PRESSURE_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_MIN_CONST_SPEED_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_MAX_CONST_SPEED_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_MIN_CONST_FLOW_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_MAX_CONST_FLOW_ATTRIBUTE_ID 0x000A // Ver.: always -#define ZCL_MIN_CONST_TEMP_ATTRIBUTE_ID 0x000B // Ver.: always -#define ZCL_MAX_CONST_TEMP_ATTRIBUTE_ID 0x000C // Ver.: always -#define ZCL_PUMP_STATUS_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_CAPACITY_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_SPEED_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_PUMP_POWER_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_OPERATION_MODE_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_CONTROL_MODE_ATTRIBUTE_ID 0x0021 // Ver.: always -#define ZCL_PUMP_ALARM_MASK_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_MAX_PRESSURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAX_SPEED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAX_FLOW_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MIN_CONST_PRESSURE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MAX_CONST_PRESSURE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MIN_COMP_PRESSURE_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_MAX_COMP_PRESSURE_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_MIN_CONST_SPEED_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_MAX_CONST_SPEED_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_MIN_CONST_FLOW_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_MAX_CONST_FLOW_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_MIN_CONST_TEMP_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_MAX_CONST_TEMP_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_PUMP_STATUS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CAPACITY_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_SPEED_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_PUMP_POWER_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_OPERATION_MODE_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_CONTROL_MODE_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_PUMP_ALARM_MASK_ATTRIBUTE_ID 0x0022 // Ver.: always #define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Thermostat // Cluster specification level: zcl-6.0-15-02018-001 @@ -695,60 +668,59 @@ #define ZCL_THERMOSTAT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LOCAL_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_OUTDOOR_TEMPERATURE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_THERMOSTAT_OCCUPANCY_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_PI_COOLING_DEMAND_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_PI_HEATING_DEMAND_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_HVAC_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0018 // Ver.: always -#define ZCL_MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID 0x0019 // Ver.: always -#define ZCL_REMOTE_SENSING_ATTRIBUTE_ID 0x001A // Ver.: always -#define ZCL_CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID 0x001B // Ver.: always -#define ZCL_SYSTEM_MODE_ATTRIBUTE_ID 0x001C // Ver.: always -#define ZCL_THERMOSTAT_ALARM_MASK_ATTRIBUTE_ID 0x001D // Ver.: always -#define ZCL_THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID 0x001E // Ver.: since ha-1.2-05-3520-29 -#define ZCL_START_OF_WEEK_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_OCCUPIED_SETBACK_ATTRIBUTE_ID 0x0034 // Ver.: always -#define ZCL_OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0035 // Ver.: always -#define ZCL_OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0036 // Ver.: always -#define ZCL_UNOCCUPIED_SETBACK_ATTRIBUTE_ID 0x0037 // Ver.: always -#define ZCL_UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0038 // Ver.: always -#define ZCL_UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0039 // Ver.: always -#define ZCL_EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID 0x003A // Ver.: always -#define ZCL_AC_TYPE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_CAPACITY_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_REFRIGERANT_TYPE_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_COMPRESSOR_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_ERROR_CODE_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_LOUVER_POSITION_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_COIL_TEMPERATURE_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_AC_CAPACITY_FORMAT_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCAL_TEMPERATURE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OUTDOOR_TEMPERATURE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_THERMOSTAT_OCCUPANCY_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_PI_COOLING_DEMAND_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_PI_HEATING_DEMAND_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_HVAC_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID 0x0009 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_REMOTE_SENSING_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_SYSTEM_MODE_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_THERMOSTAT_ALARM_MASK_ATTRIBUTE_ID 0x001D // Ver.: always +#define ZCL_THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID 0x001E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_START_OF_WEEK_ATTRIBUTE_ID 0x0020 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID 0x0021 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID 0x0022 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID 0x0023 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID 0x0024 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID 0x0025 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID 0x0029 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID 0x0030 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID 0x0031 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OCCUPIED_SETBACK_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_ATTRIBUTE_ID 0x0037 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID 0x0038 // Ver.: always +#define ZCL_UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID 0x0039 // Ver.: always +#define ZCL_EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID 0x003A // Ver.: always +#define ZCL_AC_TYPE_ATTRIBUTE_ID 0x0040 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_CAPACITY_ATTRIBUTE_ID 0x0041 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_REFRIGERANT_TYPE_ATTRIBUTE_ID 0x0042 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_COMPRESSOR_ATTRIBUTE_ID 0x0043 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_ERROR_CODE_ATTRIBUTE_ID 0x0044 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_LOUVER_POSITION_ATTRIBUTE_ID 0x0045 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_COIL_TEMPERATURE_ATTRIBUTE_ID 0x0046 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_AC_CAPACITY_FORMAT_ATTRIBUTE_ID 0x0047 // Ver.: since ha-1.2-05-3520-29 #define ZCL_THERMOSTAT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_THERMOSTAT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Fan Control // Cluster specification level: zcl-6.0-15-02018-001 @@ -757,13 +729,12 @@ #define ZCL_FAN_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_FAN_CONTROL_FAN_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FAN_CONTROL_FAN_MODE_SEQUENCE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_FAN_DELAY_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FAN_CONTROL_FAN_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FAN_CONTROL_FAN_MODE_SEQUENCE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FAN_DELAY_ATTRIBUTE_ID 0x0002 // Ver.: always #define ZCL_FAN_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_FAN_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Dehumidification Control // Cluster specification level: zcl-6.0-15-02018-001 @@ -772,18 +743,17 @@ #define ZCL_DEHUMID_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_RELATIVE_HUMIDITY_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_DEHUMIDIFICATION_COOLING_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_RH_DEHUMIDIFICATION_SETPOINT_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_RELATIVE_HUMIDITY_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_DEHUMIDIFICATION_LOCKOUT_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_DEHUMIDIFICATION_HYSTERESIS_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_DEHUMIDIFICATION_MAX_COOL_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_RELATIVE_HUMIDITY_DISPLAY_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DEHUMIDIFICATION_COOLING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_RH_DEHUMIDIFICATION_SETPOINT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MODE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_DEHUMIDIFICATION_LOCKOUT_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_DEHUMIDIFICATION_HYSTERESIS_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_DEHUMIDIFICATION_MAX_COOL_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_DISPLAY_ATTRIBUTE_ID 0x0015 // Ver.: always #define ZCL_DEHUMID_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DEHUMID_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Thermostat User Interface Configuration // Cluster specification level: zcl-6.0-15-02018-001 @@ -792,15 +762,14 @@ #define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_KEYPAD_LOCKOUT_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID 0x0002 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_BACKLIGHT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SETPOINT_SOURCE_INDICATION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEYPAD_LOCKOUT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID 0x0002 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_BACKLIGHT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SETPOINT_SOURCE_INDICATION_ATTRIBUTE_ID 0x0004 // Ver.: always #define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Color Control // Cluster specification level: zcl6-errata-14-0129-15 @@ -809,62 +778,61 @@ #define ZCL_COLOR_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_COLOR_CONTROL_CURRENT_SATURATION_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_COLOR_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_COLOR_CONTROL_CURRENT_X_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_COLOR_CONTROL_CURRENT_Y_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_COLOR_CONTROL_DRIFT_COMPENSATION_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_COLOR_CONTROL_COMPENSATION_TEXT_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_TEMPERATURE_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_MODE_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_COLOR_CONTROL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_COLOR_CONTROL_NUMBER_OF_PRIMARIES_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_1_X_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_1_Y_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_1_INTENSITY_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_2_X_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_2_Y_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_2_INTENSITY_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_3_X_ATTRIBUTE_ID 0x0019 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_3_Y_ATTRIBUTE_ID 0x001A // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_3_INTENSITY_ATTRIBUTE_ID 0x001B // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_4_X_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_4_Y_ATTRIBUTE_ID 0x0021 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_4_INTENSITY_ATTRIBUTE_ID 0x0022 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_5_X_ATTRIBUTE_ID 0x0024 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_5_Y_ATTRIBUTE_ID 0x0025 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_5_INTENSITY_ATTRIBUTE_ID 0x0026 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_6_X_ATTRIBUTE_ID 0x0028 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_6_Y_ATTRIBUTE_ID 0x0029 // Ver.: always -#define ZCL_COLOR_CONTROL_PRIMARY_6_INTENSITY_ATTRIBUTE_ID 0x002A // Ver.: always -#define ZCL_COLOR_CONTROL_WHITE_POINT_X_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_COLOR_CONTROL_WHITE_POINT_Y_ATTRIBUTE_ID 0x0031 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_R_X_ATTRIBUTE_ID 0x0032 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_R_Y_ATTRIBUTE_ID 0x0033 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID 0x0034 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_G_X_ATTRIBUTE_ID 0x0036 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_G_Y_ATTRIBUTE_ID 0x0037 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID 0x0038 // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_B_X_ATTRIBUTE_ID 0x003A // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_B_Y_ATTRIBUTE_ID 0x003B // Ver.: always -#define ZCL_COLOR_CONTROL_COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID 0x003C // Ver.: always -#define ZCL_COLOR_CONTROL_ENHANCED_CURRENT_HUE_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_ENHANCED_COLOR_MODE_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_LOOP_ACTIVE_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_LOOP_DIRECTION_ATTRIBUTE_ID 0x4003 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_LOOP_TIME_ATTRIBUTE_ID 0x4004 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID 0x4005 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID 0x4006 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_CAPABILITIES_ATTRIBUTE_ID 0x400A // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_ATTRIBUTE_ID 0x400B // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_ATTRIBUTE_ID 0x400C // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_CONTROL_TEMPERATURE_LEVEL_MIN_MIREDS_ATTRIBUTE_ID 0x400D // Ver.: since l&o-1.0-15-0014-04 -#define ZCL_START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID 0x4010 // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_SATURATION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COLOR_CONTROL_REMAINING_TIME_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_X_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_COLOR_CONTROL_CURRENT_Y_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_COLOR_CONTROL_DRIFT_COMPENSATION_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_COLOR_CONTROL_COMPENSATION_TEXT_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_TEMPERATURE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_MODE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_COLOR_CONTROL_OPTIONS_ATTRIBUTE_ID 0x000F // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_COLOR_CONTROL_NUMBER_OF_PRIMARIES_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_X_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_Y_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_1_INTENSITY_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_X_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_Y_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_2_INTENSITY_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_X_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_Y_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_3_INTENSITY_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_X_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_Y_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_4_INTENSITY_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_X_ATTRIBUTE_ID 0x0024 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_Y_ATTRIBUTE_ID 0x0025 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_5_INTENSITY_ATTRIBUTE_ID 0x0026 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_X_ATTRIBUTE_ID 0x0028 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_Y_ATTRIBUTE_ID 0x0029 // Ver.: always +#define ZCL_COLOR_CONTROL_PRIMARY_6_INTENSITY_ATTRIBUTE_ID 0x002A // Ver.: always +#define ZCL_COLOR_CONTROL_WHITE_POINT_X_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_COLOR_CONTROL_WHITE_POINT_Y_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_X_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_Y_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_X_ATTRIBUTE_ID 0x0036 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_Y_ATTRIBUTE_ID 0x0037 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID 0x0038 // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_X_ATTRIBUTE_ID 0x003A // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_Y_ATTRIBUTE_ID 0x003B // Ver.: always +#define ZCL_COLOR_CONTROL_COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID 0x003C // Ver.: always +#define ZCL_COLOR_CONTROL_ENHANCED_CURRENT_HUE_ATTRIBUTE_ID 0x4000 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_ENHANCED_COLOR_MODE_ATTRIBUTE_ID 0x4001 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_ACTIVE_ATTRIBUTE_ID 0x4002 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_DIRECTION_ATTRIBUTE_ID 0x4003 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_TIME_ATTRIBUTE_ID 0x4004 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID 0x4005 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID 0x4006 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_CAPABILITIES_ATTRIBUTE_ID 0x400A // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_ATTRIBUTE_ID 0x400B // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_ATTRIBUTE_ID 0x400C // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COLOR_CONTROL_TEMPERATURE_LEVEL_MIN_MIREDS_ATTRIBUTE_ID 0x400D // Ver.: since l&o-1.0-15-0014-04 +#define ZCL_START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID 0x4010 // Ver.: since l&o-1.0-15-0014-04 #define ZCL_COLOR_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_COLOR_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Ballast Configuration // Cluster specification level: zcl6-errata-14-0129-15 @@ -873,26 +841,25 @@ #define ZCL_BALLAST_CONFIGURATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BALLAST_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_MIN_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_MAX_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_POWER_ON_LEVEL_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_POWER_ON_FADE_TIME_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_LAMP_QUALITY_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_LAMP_TYPE_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_LAMP_MANUFACTURER_ATTRIBUTE_ID 0x0031 // Ver.: always -#define ZCL_LAMP_RATED_HOURS_ATTRIBUTE_ID 0x0032 // Ver.: always -#define ZCL_LAMP_BURN_HOURS_ATTRIBUTE_ID 0x0033 // Ver.: always -#define ZCL_LAMP_ALARM_MODE_ATTRIBUTE_ID 0x0034 // Ver.: always -#define ZCL_LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BALLAST_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MIN_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_MAX_LEVEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_POWER_ON_LEVEL_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_POWER_ON_FADE_TIME_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_LAMP_QUALITY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_LAMP_TYPE_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_LAMP_MANUFACTURER_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_LAMP_RATED_HOURS_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_LAMP_BURN_HOURS_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_LAMP_ALARM_MODE_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID 0x0035 // Ver.: always #define ZCL_BALLAST_CONFIGURATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BALLAST_CONFIGURATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Illuminance Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -901,15 +868,14 @@ #define ZCL_ILLUM_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ILLUM_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ILLUM_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ILLUM_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ILLUM_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_ILLUM_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ILLUM_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ILLUM_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ILLUM_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0004 // Ver.: always #define ZCL_ILLUM_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ILLUM_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Illuminance Level Sensing // Cluster specification level: zcl-6.0-15-02018-001 @@ -918,13 +884,12 @@ #define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LEVEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SENSING_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ILLUMINANCE_TARGET_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_LEVEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SENSING_LIGHT_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ILLUMINANCE_TARGET_LEVEL_ATTRIBUTE_ID 0x0010 // Ver.: always #define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Temperature Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -933,14 +898,13 @@ #define ZCL_TEMP_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TEMP_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TEMP_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TEMP_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_TEMP_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TEMP_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TEMP_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TEMP_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TEMP_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_TEMP_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_TEMP_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Pressure Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -949,19 +913,18 @@ #define ZCL_PRESSURE_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PRESSURE_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_PRESSURE_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_PRESSURE_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_PRESSURE_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_PRESSURE_SCALED_VALUE_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_PRESSURE_MIN_SCALED_VALUE_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_PRESSURE_MAX_SCALED_VALUE_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_PRESSURE_SCALED_TOLERANCE_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_PRESSURE_SCALE_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_PRESSURE_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PRESSURE_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PRESSURE_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PRESSURE_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PRESSURE_SCALED_VALUE_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PRESSURE_MIN_SCALED_VALUE_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_PRESSURE_MAX_SCALED_VALUE_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_PRESSURE_SCALED_TOLERANCE_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_PRESSURE_SCALE_ATTRIBUTE_ID 0x0014 // Ver.: always #define ZCL_PRESSURE_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_PRESSURE_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Flow Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -970,14 +933,13 @@ #define ZCL_FLOW_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_FLOW_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FLOW_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_FLOW_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_FLOW_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FLOW_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FLOW_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FLOW_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FLOW_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_FLOW_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_FLOW_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Relative Humidity Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -986,14 +948,13 @@ #define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_RELATIVE_HUMIDITY_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_RELATIVE_HUMIDITY_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_RELATIVE_HUMIDITY_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_RELATIVE_HUMIDITY_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_RELATIVE_HUMIDITY_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Occupancy Sensing // Cluster specification level: zcl-6.0-15-02018-001 @@ -1002,149 +963,172 @@ #define ZCL_OCCUPANCY_SENSING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_OCCUPANCY_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0021 // Ver.: always -#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0022 // Ver.: always -#define ZCL_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_OCCUPANCY_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID 0x0031 // Ver.: always #define ZCL_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID 0x0032 // Ver.: always #define ZCL_OCCUPANCY_SENSING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OCCUPANCY_SENSING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Carbon Monoxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Carbon Dioxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Ethylene Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Ethylene Oxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Hydrogen Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Hydrogen Sulphide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Nitric Oxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Nitrogen Dioxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Oxygen Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -1154,14 +1138,13 @@ #define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Ozone Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -1170,189 +1153,221 @@ #define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Sulfur Dioxide Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Dissolved Oxygen Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Bromate Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Chloramines Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Chlorine Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Fecal coliform and E. Coli Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Fluoride Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Haloacetic Acids Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Total Trihalomethanes Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Total Coliform Bacteria Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Turbidity Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Copper Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -1362,14 +1377,13 @@ #define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Lead Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -1378,109 +1392,126 @@ #define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Manganese Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Sulfate Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Bromodichloromethane Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Bromoform Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Chlorodibromomethane Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Chloroform Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 // Client attributes -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID \ + 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID \ + 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Sodium Concentration Measurement // Cluster specification level: zcl-6.0-15-02018-001 @@ -1490,14 +1521,13 @@ #define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MEASURED_VALUE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MIN_MEASURED_VALUE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_MAX_MEASURED_VALUE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_TOLERANCE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: IAS Zone // Cluster specification level: zcl-6.0-15-02018-001 @@ -1506,16 +1536,15 @@ #define ZCL_IAS_ZONE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ZONE_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ZONE_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_ZONE_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_IAS_CIE_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_ZONE_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_ZONE_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ZONE_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ZONE_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_IAS_CIE_ADDRESS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_ZONE_ID_ATTRIBUTE_ID 0x0011 // Ver.: always #define ZCL_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_CURRENT_ZONE_SENSITIVITY_LEVEL_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_IAS_ZONE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_IAS_ZONE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CURRENT_ZONE_SENSITIVITY_LEVEL_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_IAS_ZONE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_IAS_ZONE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: IAS ACE // Cluster specification level: zcl-6.0-15-02018-001 @@ -1528,7 +1557,6 @@ #define ZCL_IAS_ACE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_IAS_ACE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: IAS WD // Cluster specification level: zcl-6.0-15-02018-001 @@ -1537,11 +1565,10 @@ #define ZCL_IAS_WD_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MAX_DURATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAX_DURATION_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_IAS_WD_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_IAS_WD_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Generic Tunnel // Cluster specification level: cba-1.0-05-3516-12 @@ -1550,13 +1577,12 @@ #define ZCL_GENERIC_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_PROTOCOL_ADDRESS_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MAXIMUM_INCOMING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAXIMUM_OUTGOING_TRANSFER_SIZE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PROTOCOL_ADDRESS_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_GENERIC_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_GENERIC_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: BACnet Protocol Tunnel // Cluster specification level: cba-1.0-05-3516-12 @@ -1568,7 +1594,6 @@ #define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: 11073 Protocol Tunnel // Cluster specification level: hc-1.0-07-5360-15 @@ -1577,16 +1602,15 @@ #define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_DEVICE_ID_LIST_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MANAGER_TARGET_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MANAGER_ENDPOINT_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CONNECTED_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_PREEMPTIBLE_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_IDLE_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_DEVICE_ID_LIST_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MANAGER_TARGET_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MANAGER_ENDPOINT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CONNECTED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_PREEMPTIBLE_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_IDLE_TIMEOUT_ATTRIBUTE_ID 0x0005 // Ver.: always #define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: ISO 7816 Protocol Tunnel // Cluster specification level: ta-1.0-07-5307-07 @@ -1595,1046 +1619,1044 @@ #define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ISO7816_PROTOCOL_TUNNEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ISO7816_PROTOCOL_TUNNEL_STATUS_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Price // Cluster specification level: se-1.2b-15-0131-02 // Client attributes -#define ZCL_PRICE_INCREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_PRICE_DECREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_COMMODITY_TYPE_CLIENT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PRICE_INCREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PRICE_DECREASE_RANDOMIZE_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_COMMODITY_TYPE_CLIENT_ATTRIBUTE_ID 0x0002 // Ver.: always #define ZCL_PRICE_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_PRICE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x000A // Ver.: always -#define ZCL_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x000B // Ver.: always -#define ZCL_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x000C // Ver.: always -#define ZCL_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x000D // Ver.: always -#define ZCL_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x000E // Ver.: always -#define ZCL_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x000F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x001A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x001B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x001C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x0023 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x0024 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x0025 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x0026 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x0027 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x0028 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x0029 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x002A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x002B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x002C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x002D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x002E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x002F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0103 // Ver.: always -#define ZCL_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0104 // Ver.: always -#define ZCL_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0105 // Ver.: always -#define ZCL_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0106 // Ver.: always -#define ZCL_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0107 // Ver.: always -#define ZCL_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0108 // Ver.: always -#define ZCL_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0109 // Ver.: always -#define ZCL_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x010A // Ver.: always -#define ZCL_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x010B // Ver.: always -#define ZCL_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x010C // Ver.: always -#define ZCL_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x010D // Ver.: always -#define ZCL_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x010E // Ver.: always -#define ZCL_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x010F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x011A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x011B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x011C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x011D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER1_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER2_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER3_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER4_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER5_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0160 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0161 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0162 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0163 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0164 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0165 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0166 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0167 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0168 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0169 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x016A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x016B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x016C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x016D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x016E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER6_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x016F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0170 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0171 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0172 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0173 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0174 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0175 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0176 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0177 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0178 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0179 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x017A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x017B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x017C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x017D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x017E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER7_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x017F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0180 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0181 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0182 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0183 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0184 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0185 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0186 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0187 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0188 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0189 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x018A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x018B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x018C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x018D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x018E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER8_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x018F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0190 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0191 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0192 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0193 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0194 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0195 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0196 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0197 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0198 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0199 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x019A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x019B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x019C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x019D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x019E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER9_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x019F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01A0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01A1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01A2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01A3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01A4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01A5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01A6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01A7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01A8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01A9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01AA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01AB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01AC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01AD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01AE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER10_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01AF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01B0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01B1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01B2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01B3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01B4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01B5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01B6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01B7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01B8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01B9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01BA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01BB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01BC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01BD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01BE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER11_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01BF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01C0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01C1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01C2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01C3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01C4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01C5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01C6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01C7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01C8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01C9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01CA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01CB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01CC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01CD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01CE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER12_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01CF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01D0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01D1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01D2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01D3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01D4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01D5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01D6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01D7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01D8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01D9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01DA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01DB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01DC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01DD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01DE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER13_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01DF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01E0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01E1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01E2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01E3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01E4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01E5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01E6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01E7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01E8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01E9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01EA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01EB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01EC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01ED // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01EE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER14_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01EF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01F0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01F1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01F2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01F3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01F4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01F5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01F6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01F7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01F8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01F9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01FA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01FB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01FD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER15_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01FF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x0200 // Ver.: always -#define ZCL_BLOCK_PERIOD_DURATION_MINUTES_ATTRIBUTE_ID 0x0201 // Ver.: always -#define ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always -#define ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always -#define ZCL_BLOCK_PERIOD_DURATION_TYPE_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_COMMODITY_TYPE_SERVER_ATTRIBUTE_ID 0x0300 // Ver.: always -#define ZCL_STANDING_CHARGE_ATTRIBUTE_ID 0x0301 // Ver.: always -#define ZCL_CONVERSION_FACTOR_ATTRIBUTE_ID 0x0302 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_CONVERSION_FACTOR_TRAILING_DIGIT_ATTRIBUTE_ID 0x0303 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_CALORIFIC_VALUE_ATTRIBUTE_ID 0x0304 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_CALORIFIC_VALUE_UNIT_ATTRIBUTE_ID 0x0305 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_CALORIFIC_VALUE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0306 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x0400 // Ver.: always -#define ZCL_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x0401 // Ver.: always -#define ZCL_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x0402 // Ver.: always -#define ZCL_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x0403 // Ver.: always -#define ZCL_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x0404 // Ver.: always -#define ZCL_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x0405 // Ver.: always -#define ZCL_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x0406 // Ver.: always -#define ZCL_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x0407 // Ver.: always -#define ZCL_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x0408 // Ver.: always -#define ZCL_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x0409 // Ver.: always -#define ZCL_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x040A // Ver.: always -#define ZCL_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x040B // Ver.: always -#define ZCL_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x040C // Ver.: always -#define ZCL_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x040D // Ver.: always -#define ZCL_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x040E // Ver.: always -#define ZCL_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x040F // Ver.: always -#define ZCL_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x0410 // Ver.: always -#define ZCL_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x0411 // Ver.: always -#define ZCL_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x0412 // Ver.: always -#define ZCL_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x0413 // Ver.: always -#define ZCL_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x0414 // Ver.: always -#define ZCL_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x0415 // Ver.: always -#define ZCL_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x0416 // Ver.: always -#define ZCL_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x0417 // Ver.: always -#define ZCL_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x0418 // Ver.: always -#define ZCL_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x0419 // Ver.: always -#define ZCL_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x041A // Ver.: always -#define ZCL_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x041B // Ver.: always -#define ZCL_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x041C // Ver.: always -#define ZCL_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x041D // Ver.: always -#define ZCL_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x041E // Ver.: always -#define ZCL_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x041F // Ver.: always -#define ZCL_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x0420 // Ver.: always -#define ZCL_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x0421 // Ver.: always -#define ZCL_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x0422 // Ver.: always -#define ZCL_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x0423 // Ver.: always -#define ZCL_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x0424 // Ver.: always -#define ZCL_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x0425 // Ver.: always -#define ZCL_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x0426 // Ver.: always -#define ZCL_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x0427 // Ver.: always -#define ZCL_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x0428 // Ver.: always -#define ZCL_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x0429 // Ver.: always -#define ZCL_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x042A // Ver.: always -#define ZCL_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x042B // Ver.: always -#define ZCL_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x042C // Ver.: always -#define ZCL_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x042D // Ver.: always -#define ZCL_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x042E // Ver.: always -#define ZCL_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x042F // Ver.: always -#define ZCL_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x0430 // Ver.: always -#define ZCL_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x0431 // Ver.: always -#define ZCL_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x0432 // Ver.: always -#define ZCL_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x0433 // Ver.: always -#define ZCL_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x0434 // Ver.: always -#define ZCL_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x0435 // Ver.: always -#define ZCL_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x0436 // Ver.: always -#define ZCL_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x0437 // Ver.: always -#define ZCL_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x0438 // Ver.: always -#define ZCL_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x0439 // Ver.: always -#define ZCL_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x043A // Ver.: always -#define ZCL_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x043B // Ver.: always -#define ZCL_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x043C // Ver.: always -#define ZCL_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x043D // Ver.: always -#define ZCL_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x043E // Ver.: always -#define ZCL_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x043F // Ver.: always -#define ZCL_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x0440 // Ver.: always -#define ZCL_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x0441 // Ver.: always -#define ZCL_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x0442 // Ver.: always -#define ZCL_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x0443 // Ver.: always -#define ZCL_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x0444 // Ver.: always -#define ZCL_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x0445 // Ver.: always -#define ZCL_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x0446 // Ver.: always -#define ZCL_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x0447 // Ver.: always -#define ZCL_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x0448 // Ver.: always -#define ZCL_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x0449 // Ver.: always -#define ZCL_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x044A // Ver.: always -#define ZCL_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x044B // Ver.: always -#define ZCL_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x044C // Ver.: always -#define ZCL_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x044D // Ver.: always -#define ZCL_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x044E // Ver.: always -#define ZCL_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x044F // Ver.: always -#define ZCL_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x0450 // Ver.: always -#define ZCL_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x0451 // Ver.: always -#define ZCL_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x0452 // Ver.: always -#define ZCL_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x0453 // Ver.: always -#define ZCL_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x0454 // Ver.: always -#define ZCL_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x0455 // Ver.: always -#define ZCL_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x0456 // Ver.: always -#define ZCL_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x0457 // Ver.: always -#define ZCL_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x0458 // Ver.: always -#define ZCL_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x0459 // Ver.: always -#define ZCL_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x045A // Ver.: always -#define ZCL_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x045B // Ver.: always -#define ZCL_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x045C // Ver.: always -#define ZCL_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x045D // Ver.: always -#define ZCL_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x045E // Ver.: always -#define ZCL_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x045F // Ver.: always -#define ZCL_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x0460 // Ver.: always -#define ZCL_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x0461 // Ver.: always -#define ZCL_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x0462 // Ver.: always -#define ZCL_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x0463 // Ver.: always -#define ZCL_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x0464 // Ver.: always -#define ZCL_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x0465 // Ver.: always -#define ZCL_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x0466 // Ver.: always -#define ZCL_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x0467 // Ver.: always -#define ZCL_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x0468 // Ver.: always -#define ZCL_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x0469 // Ver.: always -#define ZCL_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x046A // Ver.: always -#define ZCL_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x046B // Ver.: always -#define ZCL_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x046C // Ver.: always -#define ZCL_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x046D // Ver.: always -#define ZCL_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x046E // Ver.: always -#define ZCL_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x046F // Ver.: always -#define ZCL_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x0470 // Ver.: always -#define ZCL_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x0471 // Ver.: always -#define ZCL_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x0472 // Ver.: always -#define ZCL_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x0473 // Ver.: always -#define ZCL_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x0474 // Ver.: always -#define ZCL_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x0475 // Ver.: always -#define ZCL_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x0476 // Ver.: always -#define ZCL_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x0477 // Ver.: always -#define ZCL_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x0478 // Ver.: always -#define ZCL_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x0479 // Ver.: always -#define ZCL_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x047A // Ver.: always -#define ZCL_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x047B // Ver.: always -#define ZCL_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x047C // Ver.: always -#define ZCL_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x047D // Ver.: always -#define ZCL_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x047E // Ver.: always -#define ZCL_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x047F // Ver.: always -#define ZCL_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x0480 // Ver.: always -#define ZCL_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x0481 // Ver.: always -#define ZCL_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x0482 // Ver.: always -#define ZCL_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x0483 // Ver.: always -#define ZCL_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x0484 // Ver.: always -#define ZCL_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x0485 // Ver.: always -#define ZCL_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x0486 // Ver.: always -#define ZCL_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x0487 // Ver.: always -#define ZCL_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x0488 // Ver.: always -#define ZCL_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x0489 // Ver.: always -#define ZCL_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x048A // Ver.: always -#define ZCL_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x048B // Ver.: always -#define ZCL_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x048C // Ver.: always -#define ZCL_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x048D // Ver.: always -#define ZCL_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x048E // Ver.: always -#define ZCL_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x048F // Ver.: always -#define ZCL_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x0490 // Ver.: always -#define ZCL_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x0491 // Ver.: always -#define ZCL_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x0492 // Ver.: always -#define ZCL_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x0493 // Ver.: always -#define ZCL_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x0494 // Ver.: always -#define ZCL_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x0495 // Ver.: always -#define ZCL_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x0496 // Ver.: always -#define ZCL_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x0497 // Ver.: always -#define ZCL_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x0498 // Ver.: always -#define ZCL_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x0499 // Ver.: always -#define ZCL_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x049A // Ver.: always -#define ZCL_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x049B // Ver.: always -#define ZCL_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x049C // Ver.: always -#define ZCL_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x049D // Ver.: always -#define ZCL_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x049E // Ver.: always -#define ZCL_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x049F // Ver.: always -#define ZCL_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x04A0 // Ver.: always -#define ZCL_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x04A1 // Ver.: always -#define ZCL_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x04A2 // Ver.: always -#define ZCL_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x04A3 // Ver.: always -#define ZCL_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x04A4 // Ver.: always -#define ZCL_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x04A5 // Ver.: always -#define ZCL_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x04A6 // Ver.: always -#define ZCL_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x04A7 // Ver.: always -#define ZCL_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x04A8 // Ver.: always -#define ZCL_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x04A9 // Ver.: always -#define ZCL_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x04AA // Ver.: always -#define ZCL_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x04AB // Ver.: always -#define ZCL_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x04AC // Ver.: always -#define ZCL_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x04AD // Ver.: always -#define ZCL_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x04AE // Ver.: always -#define ZCL_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x04AF // Ver.: always -#define ZCL_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x04B0 // Ver.: always -#define ZCL_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x04B1 // Ver.: always -#define ZCL_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x04B2 // Ver.: always -#define ZCL_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x04B3 // Ver.: always -#define ZCL_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x04B4 // Ver.: always -#define ZCL_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x04B5 // Ver.: always -#define ZCL_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x04B6 // Ver.: always -#define ZCL_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x04B7 // Ver.: always -#define ZCL_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x04B8 // Ver.: always -#define ZCL_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x04B9 // Ver.: always -#define ZCL_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x04BA // Ver.: always -#define ZCL_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x04BB // Ver.: always -#define ZCL_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x04BC // Ver.: always -#define ZCL_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x04BD // Ver.: always -#define ZCL_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x04BE // Ver.: always -#define ZCL_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x04BF // Ver.: always -#define ZCL_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x04C0 // Ver.: always -#define ZCL_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x04C1 // Ver.: always -#define ZCL_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x04C2 // Ver.: always -#define ZCL_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x04C3 // Ver.: always -#define ZCL_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x04C4 // Ver.: always -#define ZCL_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x04C5 // Ver.: always -#define ZCL_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x04C6 // Ver.: always -#define ZCL_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x04C7 // Ver.: always -#define ZCL_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x04C8 // Ver.: always -#define ZCL_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x04C9 // Ver.: always -#define ZCL_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x04CA // Ver.: always -#define ZCL_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x04CB // Ver.: always -#define ZCL_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x04CC // Ver.: always -#define ZCL_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x04CD // Ver.: always -#define ZCL_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x04CE // Ver.: always -#define ZCL_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x04CF // Ver.: always -#define ZCL_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x04D0 // Ver.: always -#define ZCL_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x04D1 // Ver.: always -#define ZCL_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x04D2 // Ver.: always -#define ZCL_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x04D3 // Ver.: always -#define ZCL_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x04D4 // Ver.: always -#define ZCL_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x04D5 // Ver.: always -#define ZCL_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x04D6 // Ver.: always -#define ZCL_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x04D7 // Ver.: always -#define ZCL_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x04D8 // Ver.: always -#define ZCL_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x04D9 // Ver.: always -#define ZCL_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x04DA // Ver.: always -#define ZCL_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x04DB // Ver.: always -#define ZCL_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x04DC // Ver.: always -#define ZCL_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x04DD // Ver.: always -#define ZCL_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x04DE // Ver.: always -#define ZCL_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x04DF // Ver.: always -#define ZCL_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x04E0 // Ver.: always -#define ZCL_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x04E1 // Ver.: always -#define ZCL_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x04E2 // Ver.: always -#define ZCL_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x04E3 // Ver.: always -#define ZCL_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x04E4 // Ver.: always -#define ZCL_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x04E5 // Ver.: always -#define ZCL_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x04E6 // Ver.: always -#define ZCL_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x04E7 // Ver.: always -#define ZCL_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x04E8 // Ver.: always -#define ZCL_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x04E9 // Ver.: always -#define ZCL_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x04EA // Ver.: always -#define ZCL_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x04EB // Ver.: always -#define ZCL_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x04EC // Ver.: always -#define ZCL_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x04ED // Ver.: always -#define ZCL_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x04EE // Ver.: always -#define ZCL_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x04EF // Ver.: always -#define ZCL_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x04F0 // Ver.: always -#define ZCL_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x04F1 // Ver.: always -#define ZCL_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x04F2 // Ver.: always -#define ZCL_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x04F3 // Ver.: always -#define ZCL_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x04F4 // Ver.: always -#define ZCL_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x04F5 // Ver.: always -#define ZCL_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x04F6 // Ver.: always -#define ZCL_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x04F7 // Ver.: always -#define ZCL_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x04F8 // Ver.: always -#define ZCL_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x04F9 // Ver.: always -#define ZCL_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x04FA // Ver.: always -#define ZCL_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x04FB // Ver.: always -#define ZCL_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x04FC // Ver.: always -#define ZCL_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x04FD // Ver.: always -#define ZCL_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x04FE // Ver.: always -#define ZCL_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x04FF // Ver.: always -#define ZCL_PRICE_TIER16_ATTRIBUTE_ID 0x050F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER17_ATTRIBUTE_ID 0x0510 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER18_ATTRIBUTE_ID 0x0511 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER19_ATTRIBUTE_ID 0x0512 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER20_ATTRIBUTE_ID 0x0513 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER21_ATTRIBUTE_ID 0x0514 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER22_ATTRIBUTE_ID 0x0515 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER23_ATTRIBUTE_ID 0x0516 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER24_ATTRIBUTE_ID 0x0517 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER25_ATTRIBUTE_ID 0x0518 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER26_ATTRIBUTE_ID 0x0519 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER27_ATTRIBUTE_ID 0x051A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER28_ATTRIBUTE_ID 0x051B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER29_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER30_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER31_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER32_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER33_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER34_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER35_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER36_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER37_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER38_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER39_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER40_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER41_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER42_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER43_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER44_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER45_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER46_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER47_ATTRIBUTE_ID 0x052E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_TIER48_ATTRIBUTE_ID 0x052F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CPP1_PRICE_ATTRIBUTE_ID 0x05FE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CPP2_PRICE_ATTRIBUTE_ID 0x05FF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_LABEL_ATTRIBUTE_ID 0x0610 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x0611 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x0612 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x0613 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0615 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_CURRENCY_ATTRIBUTE_ID 0x0616 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0617 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x0619 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_CO2_ATTRIBUTE_ID 0x0620 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_CO2_UNIT_ATTRIBUTE_ID 0x0621 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TARIFF_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x0622 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1b-07-5356-18 -#define ZCL_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1b-07-5356-18 -#define ZCL_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LAST_BILLING_PERIOD_CONSOLIDATED_BILL_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DUE_DATE_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_STATUS_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_OVER_DUE_AMOUNT_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PAYMENT_DISCOUNT_ATTRIBUTE_ID 0x080A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PAYMENT_DISCOUNT_PERIOD_ATTRIBUTE_ID 0x080B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_1_ATTRIBUTE_ID 0x0810 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DATE_1_ATTRIBUTE_ID 0x0811 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_REF_1_ATTRIBUTE_ID 0x0812 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_2_ATTRIBUTE_ID 0x0820 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DATE_2_ATTRIBUTE_ID 0x0821 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_REF_2_ATTRIBUTE_ID 0x0822 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_3_ATTRIBUTE_ID 0x0830 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DATE_3_ATTRIBUTE_ID 0x0831 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_REF_3_ATTRIBUTE_ID 0x0832 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_4_ATTRIBUTE_ID 0x0840 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DATE_4_ATTRIBUTE_ID 0x0841 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_REF_4_ATTRIBUTE_ID 0x0842 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_5_ATTRIBUTE_ID 0x0850 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_DATE_5_ATTRIBUTE_ID 0x0851 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_PAYMENT_REF_5_ATTRIBUTE_ID 0x0852 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x8000 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x8001 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x8002 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x8003 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x8004 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x8005 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x8006 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x8007 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x8008 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x8009 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x800A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x800B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x800C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x800D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x800E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x800F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x8010 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x8011 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x8012 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x8013 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x8014 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x8015 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x8016 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x8017 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x8018 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x8019 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x801A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x801B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x801C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x801D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x801E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x801F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x8020 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x8021 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x8022 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x8023 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x8024 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x8025 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x8026 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x8027 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x8028 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x8029 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x802A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x802B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x802C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x802D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x802E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x802F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x8100 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x8101 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x8102 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x8103 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x8104 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x8105 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x8106 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x8107 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x8108 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x8109 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x810A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x810B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x810C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x810D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x810E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x8200 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_BLOCK_PERIOD_DURATION_ATTRIBUTE_ID 0x8201 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x8202 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x8203 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x8400 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x8401 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x8402 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x8403 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x8404 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x8405 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x8406 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x8407 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x8408 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x8409 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x840A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x840B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x840C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x840D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x840E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x840F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x8410 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x8411 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x8412 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x8413 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x8414 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x8415 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x8416 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x8417 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x8418 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x8419 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x841A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x841B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x841C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x841D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x841E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x841F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x8420 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x8421 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x8422 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x8423 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x8424 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x8425 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x8426 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x8427 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x8428 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x8429 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x842A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x842B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x842C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x842D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x842E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x842F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x8430 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x8431 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x8432 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x8433 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x8434 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x8435 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x8436 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x8437 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x8438 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x8439 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x843A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x843B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x843C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x843D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x843E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x843F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x8440 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x8441 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x8442 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x8443 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x8444 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x8445 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x8446 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x8447 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x8448 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x8449 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x844A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x844B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x844C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x844D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x844E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x844F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x8450 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x8451 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x8452 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x8453 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x8454 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x8455 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x8456 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x8457 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x8458 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x8459 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x845A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x845B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x845C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x845D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x845E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x845F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x8460 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x8461 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x8462 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x8463 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x8464 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x8465 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x8466 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x8467 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x8468 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x8469 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x846A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x846B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x846C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x846D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x846E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x846F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x8470 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x8471 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x8472 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x8473 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x8474 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x8475 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x8476 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x8477 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x8478 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x8479 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x847A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x847B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x847C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x847D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x847E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x847F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x8480 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x8481 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x8482 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x8483 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x8484 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x8485 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x8486 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x8487 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x8488 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x8489 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x848A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x848B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x848C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x848D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x848E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x848F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x8490 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x8491 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x8492 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x8493 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x8494 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x8495 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x8496 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x8497 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x8498 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x8499 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x849A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x849B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x849C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x849D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x849E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x849F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x84A0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x84A1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x84A2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x84A3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x84A4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x84A5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x84A6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x84A7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x84A8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x84A9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x84AA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x84AB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x84AC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x84AD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x84AE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x84AF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x84B0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x84B1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x84B2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x84B3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x84B4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x84B5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x84B6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x84B7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x84B8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x84B9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x84BA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x84BB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x84BC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x84BD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x84BE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x84BF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x84C0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x84C1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x84C2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x84C3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x84C4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x84C5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x84C6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x84C7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x84C8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x84C9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x84CA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x84CB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x84CC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x84CD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x84CE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x84CF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x84D0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x84D1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x84D2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x84D3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x84D4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x84D5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x84D6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x84D7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x84D8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x84D9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x84DA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x84DB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x84DC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x84DD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x84DE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x84DF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x84E0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x84E1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x84E2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x84E3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x84E4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x84E5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x84E6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x84E7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x84E8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x84E9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x84EA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x84EB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x84EC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x84ED // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x84EE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x84EF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x84F0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x84F1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x84F2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x84F3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x84F4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x84F5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x84F6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x84F7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x84F8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x84F9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x84FA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x84FB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x84FC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x84FD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x84FE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x84FF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER16_ATTRIBUTE_ID 0x850F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER17_ATTRIBUTE_ID 0x8510 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER18_ATTRIBUTE_ID 0x8511 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER19_ATTRIBUTE_ID 0x8512 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER20_ATTRIBUTE_ID 0x8513 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER21_ATTRIBUTE_ID 0x8514 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER22_ATTRIBUTE_ID 0x8515 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER23_ATTRIBUTE_ID 0x8516 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER24_ATTRIBUTE_ID 0x8517 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER25_ATTRIBUTE_ID 0x8518 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER26_ATTRIBUTE_ID 0x8519 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER27_ATTRIBUTE_ID 0x851A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER28_ATTRIBUTE_ID 0x851B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER29_ATTRIBUTE_ID 0x851C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER30_ATTRIBUTE_ID 0x851D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER31_ATTRIBUTE_ID 0x851E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER32_ATTRIBUTE_ID 0x851F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER33_ATTRIBUTE_ID 0x8520 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER34_ATTRIBUTE_ID 0x8521 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER35_ATTRIBUTE_ID 0x8522 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER36_ATTRIBUTE_ID 0x8523 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER37_ATTRIBUTE_ID 0x8524 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER38_ATTRIBUTE_ID 0x8525 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER39_ATTRIBUTE_ID 0x8526 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER40_ATTRIBUTE_ID 0x8527 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER41_ATTRIBUTE_ID 0x8528 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER42_ATTRIBUTE_ID 0x8529 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER43_ATTRIBUTE_ID 0x852A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER44_ATTRIBUTE_ID 0x852B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER45_ATTRIBUTE_ID 0x852C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER46_ATTRIBUTE_ID 0x852D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER47_ATTRIBUTE_ID 0x852E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_PRICE_TIER48_ATTRIBUTE_ID 0x852F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TARIFF_LABEL_ATTRIBUTE_ID 0x8610 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x8611 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x8612 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x8613 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x8615 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_CO2_ATTRIBUTE_ID 0x8625 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_CO2_UNIT_ATTRIBUTE_ID 0x8626 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x8627 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8700 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8701 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8702 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RX_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8703 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x000F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x001A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x001B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x001C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x0023 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x0024 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x0025 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x0026 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x0027 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x0028 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x0029 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x002A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x002B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x002C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x002D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x002E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x002F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x010E // Ver.: always +#define ZCL_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x010F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x011A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x011B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x011C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x011D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER1_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER2_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER3_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER4_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER5_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0160 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0161 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0162 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0163 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0164 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0165 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0166 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0167 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0168 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0169 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x016A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x016B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x016C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x016D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x016E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER6_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x016F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0170 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0171 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0172 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0173 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0174 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0175 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0176 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0177 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0178 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0179 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x017A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x017B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x017C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x017D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x017E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER7_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x017F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0180 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0181 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0182 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0183 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0184 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0185 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0186 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0187 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0188 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0189 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x018A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x018B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x018C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x018D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x018E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER8_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x018F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x0190 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x0191 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x0192 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x0193 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x0194 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x0195 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x0196 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x0197 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x0198 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x0199 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x019A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x019B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x019C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x019D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x019E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER9_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x019F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER10_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER11_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER12_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER13_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER14_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x01F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x01F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x01F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x01F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x01F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x01F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x01F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x01F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x01F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x01F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x01FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x01FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x01FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER15_BLOCK_THRESHOLD_COUNT_ATTRIBUTE_ID 0x01FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_BLOCK_PERIOD_DURATION_MINUTES_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_BLOCK_PERIOD_DURATION_TYPE_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_COMMODITY_TYPE_SERVER_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_STANDING_CHARGE_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_CONVERSION_FACTOR_ATTRIBUTE_ID 0x0302 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CONVERSION_FACTOR_TRAILING_DIGIT_ATTRIBUTE_ID 0x0303 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_ATTRIBUTE_ID 0x0304 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_UNIT_ATTRIBUTE_ID 0x0305 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_CALORIFIC_VALUE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0306 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x0406 // Ver.: always +#define ZCL_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x0407 // Ver.: always +#define ZCL_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x0408 // Ver.: always +#define ZCL_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x0409 // Ver.: always +#define ZCL_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x040A // Ver.: always +#define ZCL_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x040B // Ver.: always +#define ZCL_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x040C // Ver.: always +#define ZCL_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x040D // Ver.: always +#define ZCL_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x040E // Ver.: always +#define ZCL_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x040F // Ver.: always +#define ZCL_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x0410 // Ver.: always +#define ZCL_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x0411 // Ver.: always +#define ZCL_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x0412 // Ver.: always +#define ZCL_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x0413 // Ver.: always +#define ZCL_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x0414 // Ver.: always +#define ZCL_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x0415 // Ver.: always +#define ZCL_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x0416 // Ver.: always +#define ZCL_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x0417 // Ver.: always +#define ZCL_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x0418 // Ver.: always +#define ZCL_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x0419 // Ver.: always +#define ZCL_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x041A // Ver.: always +#define ZCL_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x041B // Ver.: always +#define ZCL_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x041C // Ver.: always +#define ZCL_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x041D // Ver.: always +#define ZCL_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x041E // Ver.: always +#define ZCL_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x041F // Ver.: always +#define ZCL_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x0420 // Ver.: always +#define ZCL_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x0421 // Ver.: always +#define ZCL_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x0422 // Ver.: always +#define ZCL_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x0423 // Ver.: always +#define ZCL_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x0424 // Ver.: always +#define ZCL_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x0425 // Ver.: always +#define ZCL_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x0426 // Ver.: always +#define ZCL_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x0427 // Ver.: always +#define ZCL_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x0428 // Ver.: always +#define ZCL_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x0429 // Ver.: always +#define ZCL_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x042A // Ver.: always +#define ZCL_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x042B // Ver.: always +#define ZCL_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x042C // Ver.: always +#define ZCL_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x042D // Ver.: always +#define ZCL_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x042E // Ver.: always +#define ZCL_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x042F // Ver.: always +#define ZCL_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x0430 // Ver.: always +#define ZCL_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x0431 // Ver.: always +#define ZCL_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x0432 // Ver.: always +#define ZCL_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x0433 // Ver.: always +#define ZCL_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x0434 // Ver.: always +#define ZCL_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x0435 // Ver.: always +#define ZCL_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x0436 // Ver.: always +#define ZCL_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x0437 // Ver.: always +#define ZCL_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x0438 // Ver.: always +#define ZCL_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x0439 // Ver.: always +#define ZCL_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x043A // Ver.: always +#define ZCL_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x043B // Ver.: always +#define ZCL_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x043C // Ver.: always +#define ZCL_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x043D // Ver.: always +#define ZCL_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x043E // Ver.: always +#define ZCL_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x043F // Ver.: always +#define ZCL_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x0440 // Ver.: always +#define ZCL_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x0441 // Ver.: always +#define ZCL_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x0442 // Ver.: always +#define ZCL_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x0443 // Ver.: always +#define ZCL_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x0444 // Ver.: always +#define ZCL_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x0445 // Ver.: always +#define ZCL_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x0446 // Ver.: always +#define ZCL_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x0447 // Ver.: always +#define ZCL_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x0448 // Ver.: always +#define ZCL_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x0449 // Ver.: always +#define ZCL_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x044A // Ver.: always +#define ZCL_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x044B // Ver.: always +#define ZCL_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x044C // Ver.: always +#define ZCL_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x044D // Ver.: always +#define ZCL_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x044E // Ver.: always +#define ZCL_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x044F // Ver.: always +#define ZCL_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x0450 // Ver.: always +#define ZCL_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x0451 // Ver.: always +#define ZCL_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x0452 // Ver.: always +#define ZCL_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x0453 // Ver.: always +#define ZCL_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x0454 // Ver.: always +#define ZCL_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x0455 // Ver.: always +#define ZCL_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x0456 // Ver.: always +#define ZCL_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x0457 // Ver.: always +#define ZCL_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x0458 // Ver.: always +#define ZCL_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x0459 // Ver.: always +#define ZCL_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x045A // Ver.: always +#define ZCL_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x045B // Ver.: always +#define ZCL_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x045C // Ver.: always +#define ZCL_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x045D // Ver.: always +#define ZCL_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x045E // Ver.: always +#define ZCL_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x045F // Ver.: always +#define ZCL_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x0460 // Ver.: always +#define ZCL_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x0461 // Ver.: always +#define ZCL_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x0462 // Ver.: always +#define ZCL_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x0463 // Ver.: always +#define ZCL_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x0464 // Ver.: always +#define ZCL_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x0465 // Ver.: always +#define ZCL_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x0466 // Ver.: always +#define ZCL_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x0467 // Ver.: always +#define ZCL_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x0468 // Ver.: always +#define ZCL_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x0469 // Ver.: always +#define ZCL_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x046A // Ver.: always +#define ZCL_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x046B // Ver.: always +#define ZCL_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x046C // Ver.: always +#define ZCL_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x046D // Ver.: always +#define ZCL_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x046E // Ver.: always +#define ZCL_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x046F // Ver.: always +#define ZCL_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x0470 // Ver.: always +#define ZCL_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x0471 // Ver.: always +#define ZCL_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x0472 // Ver.: always +#define ZCL_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x0473 // Ver.: always +#define ZCL_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x0474 // Ver.: always +#define ZCL_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x0475 // Ver.: always +#define ZCL_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x0476 // Ver.: always +#define ZCL_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x0477 // Ver.: always +#define ZCL_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x0478 // Ver.: always +#define ZCL_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x0479 // Ver.: always +#define ZCL_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x047A // Ver.: always +#define ZCL_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x047B // Ver.: always +#define ZCL_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x047C // Ver.: always +#define ZCL_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x047D // Ver.: always +#define ZCL_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x047E // Ver.: always +#define ZCL_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x047F // Ver.: always +#define ZCL_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x0480 // Ver.: always +#define ZCL_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x0481 // Ver.: always +#define ZCL_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x0482 // Ver.: always +#define ZCL_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x0483 // Ver.: always +#define ZCL_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x0484 // Ver.: always +#define ZCL_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x0485 // Ver.: always +#define ZCL_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x0486 // Ver.: always +#define ZCL_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x0487 // Ver.: always +#define ZCL_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x0488 // Ver.: always +#define ZCL_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x0489 // Ver.: always +#define ZCL_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x048A // Ver.: always +#define ZCL_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x048B // Ver.: always +#define ZCL_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x048C // Ver.: always +#define ZCL_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x048D // Ver.: always +#define ZCL_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x048E // Ver.: always +#define ZCL_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x048F // Ver.: always +#define ZCL_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x0490 // Ver.: always +#define ZCL_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x0491 // Ver.: always +#define ZCL_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x0492 // Ver.: always +#define ZCL_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x0493 // Ver.: always +#define ZCL_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x0494 // Ver.: always +#define ZCL_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x0495 // Ver.: always +#define ZCL_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x0496 // Ver.: always +#define ZCL_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x0497 // Ver.: always +#define ZCL_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x0498 // Ver.: always +#define ZCL_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x0499 // Ver.: always +#define ZCL_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x049A // Ver.: always +#define ZCL_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x049B // Ver.: always +#define ZCL_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x049C // Ver.: always +#define ZCL_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x049D // Ver.: always +#define ZCL_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x049E // Ver.: always +#define ZCL_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x049F // Ver.: always +#define ZCL_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x04A0 // Ver.: always +#define ZCL_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x04A1 // Ver.: always +#define ZCL_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x04A2 // Ver.: always +#define ZCL_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x04A3 // Ver.: always +#define ZCL_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x04A4 // Ver.: always +#define ZCL_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x04A5 // Ver.: always +#define ZCL_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x04A6 // Ver.: always +#define ZCL_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x04A7 // Ver.: always +#define ZCL_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x04A8 // Ver.: always +#define ZCL_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x04A9 // Ver.: always +#define ZCL_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x04AA // Ver.: always +#define ZCL_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x04AB // Ver.: always +#define ZCL_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x04AC // Ver.: always +#define ZCL_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x04AD // Ver.: always +#define ZCL_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x04AE // Ver.: always +#define ZCL_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x04AF // Ver.: always +#define ZCL_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x04B0 // Ver.: always +#define ZCL_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x04B1 // Ver.: always +#define ZCL_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x04B2 // Ver.: always +#define ZCL_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x04B3 // Ver.: always +#define ZCL_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x04B4 // Ver.: always +#define ZCL_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x04B5 // Ver.: always +#define ZCL_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x04B6 // Ver.: always +#define ZCL_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x04B7 // Ver.: always +#define ZCL_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x04B8 // Ver.: always +#define ZCL_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x04B9 // Ver.: always +#define ZCL_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x04BA // Ver.: always +#define ZCL_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x04BB // Ver.: always +#define ZCL_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x04BC // Ver.: always +#define ZCL_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x04BD // Ver.: always +#define ZCL_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x04BE // Ver.: always +#define ZCL_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x04BF // Ver.: always +#define ZCL_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x04C0 // Ver.: always +#define ZCL_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x04C1 // Ver.: always +#define ZCL_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x04C2 // Ver.: always +#define ZCL_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x04C3 // Ver.: always +#define ZCL_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x04C4 // Ver.: always +#define ZCL_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x04C5 // Ver.: always +#define ZCL_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x04C6 // Ver.: always +#define ZCL_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x04C7 // Ver.: always +#define ZCL_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x04C8 // Ver.: always +#define ZCL_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x04C9 // Ver.: always +#define ZCL_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x04CA // Ver.: always +#define ZCL_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x04CB // Ver.: always +#define ZCL_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x04CC // Ver.: always +#define ZCL_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x04CD // Ver.: always +#define ZCL_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x04CE // Ver.: always +#define ZCL_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x04CF // Ver.: always +#define ZCL_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x04D0 // Ver.: always +#define ZCL_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x04D1 // Ver.: always +#define ZCL_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x04D2 // Ver.: always +#define ZCL_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x04D3 // Ver.: always +#define ZCL_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x04D4 // Ver.: always +#define ZCL_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x04D5 // Ver.: always +#define ZCL_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x04D6 // Ver.: always +#define ZCL_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x04D7 // Ver.: always +#define ZCL_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x04D8 // Ver.: always +#define ZCL_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x04D9 // Ver.: always +#define ZCL_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x04DA // Ver.: always +#define ZCL_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x04DB // Ver.: always +#define ZCL_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x04DC // Ver.: always +#define ZCL_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x04DD // Ver.: always +#define ZCL_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x04DE // Ver.: always +#define ZCL_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x04DF // Ver.: always +#define ZCL_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x04E0 // Ver.: always +#define ZCL_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x04E1 // Ver.: always +#define ZCL_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x04E2 // Ver.: always +#define ZCL_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x04E3 // Ver.: always +#define ZCL_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x04E4 // Ver.: always +#define ZCL_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x04E5 // Ver.: always +#define ZCL_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x04E6 // Ver.: always +#define ZCL_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x04E7 // Ver.: always +#define ZCL_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x04E8 // Ver.: always +#define ZCL_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x04E9 // Ver.: always +#define ZCL_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x04EA // Ver.: always +#define ZCL_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x04EB // Ver.: always +#define ZCL_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x04EC // Ver.: always +#define ZCL_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x04ED // Ver.: always +#define ZCL_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x04EE // Ver.: always +#define ZCL_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x04EF // Ver.: always +#define ZCL_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x04F0 // Ver.: always +#define ZCL_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x04F1 // Ver.: always +#define ZCL_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x04F2 // Ver.: always +#define ZCL_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x04F3 // Ver.: always +#define ZCL_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x04F4 // Ver.: always +#define ZCL_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x04F5 // Ver.: always +#define ZCL_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x04F6 // Ver.: always +#define ZCL_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x04F7 // Ver.: always +#define ZCL_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x04F8 // Ver.: always +#define ZCL_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x04F9 // Ver.: always +#define ZCL_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x04FA // Ver.: always +#define ZCL_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x04FB // Ver.: always +#define ZCL_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x04FC // Ver.: always +#define ZCL_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x04FD // Ver.: always +#define ZCL_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x04FE // Ver.: always +#define ZCL_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x04FF // Ver.: always +#define ZCL_PRICE_TIER16_ATTRIBUTE_ID 0x050F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER17_ATTRIBUTE_ID 0x0510 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER18_ATTRIBUTE_ID 0x0511 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER19_ATTRIBUTE_ID 0x0512 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER20_ATTRIBUTE_ID 0x0513 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER21_ATTRIBUTE_ID 0x0514 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER22_ATTRIBUTE_ID 0x0515 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER23_ATTRIBUTE_ID 0x0516 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER24_ATTRIBUTE_ID 0x0517 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER25_ATTRIBUTE_ID 0x0518 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER26_ATTRIBUTE_ID 0x0519 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER27_ATTRIBUTE_ID 0x051A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER28_ATTRIBUTE_ID 0x051B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER29_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER30_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER31_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER32_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER33_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER34_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER35_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER36_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER37_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER38_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER39_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER40_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER41_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER42_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER43_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER44_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER45_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER46_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER47_ATTRIBUTE_ID 0x052E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PRICE_TIER48_ATTRIBUTE_ID 0x052F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP1_PRICE_ATTRIBUTE_ID 0x05FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP2_PRICE_ATTRIBUTE_ID 0x05FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_LABEL_ATTRIBUTE_ID 0x0610 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x0611 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x0612 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x0613 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0615 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CURRENCY_ATTRIBUTE_ID 0x0616 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0617 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x0619 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_ATTRIBUTE_ID 0x0620 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_UNIT_ATTRIBUTE_ID 0x0621 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TARIFF_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x0622 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1b-07-5356-18 +#define ZCL_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1b-07-5356-18 +#define ZCL_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BILLING_PERIOD_CONSOLIDATED_BILL_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DUE_DATE_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_STATUS_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_OVER_DUE_AMOUNT_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PAYMENT_DISCOUNT_ATTRIBUTE_ID 0x080A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PAYMENT_DISCOUNT_PERIOD_ATTRIBUTE_ID 0x080B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_1_ATTRIBUTE_ID 0x0810 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_1_ATTRIBUTE_ID 0x0811 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_1_ATTRIBUTE_ID 0x0812 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_2_ATTRIBUTE_ID 0x0820 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_2_ATTRIBUTE_ID 0x0821 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_2_ATTRIBUTE_ID 0x0822 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_3_ATTRIBUTE_ID 0x0830 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_3_ATTRIBUTE_ID 0x0831 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_3_ATTRIBUTE_ID 0x0832 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_4_ATTRIBUTE_ID 0x0840 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_4_ATTRIBUTE_ID 0x0841 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_4_ATTRIBUTE_ID 0x0842 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_5_ATTRIBUTE_ID 0x0850 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_DATE_5_ATTRIBUTE_ID 0x0851 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_PAYMENT_REF_5_ATTRIBUTE_ID 0x0852 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_PRICE_LABEL_ATTRIBUTE_ID 0x8000 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_PRICE_LABEL_ATTRIBUTE_ID 0x8001 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_PRICE_LABEL_ATTRIBUTE_ID 0x8002 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_PRICE_LABEL_ATTRIBUTE_ID 0x8003 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_PRICE_LABEL_ATTRIBUTE_ID 0x8004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_PRICE_LABEL_ATTRIBUTE_ID 0x8005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_PRICE_LABEL_ATTRIBUTE_ID 0x8006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_PRICE_LABEL_ATTRIBUTE_ID 0x8007 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_PRICE_LABEL_ATTRIBUTE_ID 0x8008 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_PRICE_LABEL_ATTRIBUTE_ID 0x8009 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_PRICE_LABEL_ATTRIBUTE_ID 0x800A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_PRICE_LABEL_ATTRIBUTE_ID 0x800B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_PRICE_LABEL_ATTRIBUTE_ID 0x800C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_PRICE_LABEL_ATTRIBUTE_ID 0x800D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_PRICE_LABEL_ATTRIBUTE_ID 0x800E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER16_PRICE_LABEL_ATTRIBUTE_ID 0x800F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER17_PRICE_LABEL_ATTRIBUTE_ID 0x8010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER18_PRICE_LABEL_ATTRIBUTE_ID 0x8011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER19_PRICE_LABEL_ATTRIBUTE_ID 0x8012 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER20_PRICE_LABEL_ATTRIBUTE_ID 0x8013 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER21_PRICE_LABEL_ATTRIBUTE_ID 0x8014 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER22_PRICE_LABEL_ATTRIBUTE_ID 0x8015 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER23_PRICE_LABEL_ATTRIBUTE_ID 0x8016 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER24_PRICE_LABEL_ATTRIBUTE_ID 0x8017 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER25_PRICE_LABEL_ATTRIBUTE_ID 0x8018 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER26_PRICE_LABEL_ATTRIBUTE_ID 0x8019 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER27_PRICE_LABEL_ATTRIBUTE_ID 0x801A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER28_PRICE_LABEL_ATTRIBUTE_ID 0x801B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER29_PRICE_LABEL_ATTRIBUTE_ID 0x801C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER30_PRICE_LABEL_ATTRIBUTE_ID 0x801D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER31_PRICE_LABEL_ATTRIBUTE_ID 0x801E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER32_PRICE_LABEL_ATTRIBUTE_ID 0x801F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER33_PRICE_LABEL_ATTRIBUTE_ID 0x8020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER34_PRICE_LABEL_ATTRIBUTE_ID 0x8021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER35_PRICE_LABEL_ATTRIBUTE_ID 0x8022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER36_PRICE_LABEL_ATTRIBUTE_ID 0x8023 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER37_PRICE_LABEL_ATTRIBUTE_ID 0x8024 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER38_PRICE_LABEL_ATTRIBUTE_ID 0x8025 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER39_PRICE_LABEL_ATTRIBUTE_ID 0x8026 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER40_PRICE_LABEL_ATTRIBUTE_ID 0x8027 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER41_PRICE_LABEL_ATTRIBUTE_ID 0x8028 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER42_PRICE_LABEL_ATTRIBUTE_ID 0x8029 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER43_PRICE_LABEL_ATTRIBUTE_ID 0x802A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER44_PRICE_LABEL_ATTRIBUTE_ID 0x802B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER45_PRICE_LABEL_ATTRIBUTE_ID 0x802C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER46_PRICE_LABEL_ATTRIBUTE_ID 0x802D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER47_PRICE_LABEL_ATTRIBUTE_ID 0x802E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER48_PRICE_LABEL_ATTRIBUTE_ID 0x802F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK1_THRESHOLD_ATTRIBUTE_ID 0x8100 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK2_THRESHOLD_ATTRIBUTE_ID 0x8101 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK3_THRESHOLD_ATTRIBUTE_ID 0x8102 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK4_THRESHOLD_ATTRIBUTE_ID 0x8103 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK5_THRESHOLD_ATTRIBUTE_ID 0x8104 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK6_THRESHOLD_ATTRIBUTE_ID 0x8105 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK7_THRESHOLD_ATTRIBUTE_ID 0x8106 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK8_THRESHOLD_ATTRIBUTE_ID 0x8107 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK9_THRESHOLD_ATTRIBUTE_ID 0x8108 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK10_THRESHOLD_ATTRIBUTE_ID 0x8109 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK11_THRESHOLD_ATTRIBUTE_ID 0x810A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK12_THRESHOLD_ATTRIBUTE_ID 0x810B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK13_THRESHOLD_ATTRIBUTE_ID 0x810C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK14_THRESHOLD_ATTRIBUTE_ID 0x810D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK15_THRESHOLD_ATTRIBUTE_ID 0x810E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_START_OF_BLOCK_PERIOD_ATTRIBUTE_ID 0x8200 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_BLOCK_PERIOD_DURATION_ATTRIBUTE_ID 0x8201 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID 0x8202 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_THRESHOLD_DIVISOR_ATTRIBUTE_ID 0x8203 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK1_PRICE_ATTRIBUTE_ID 0x8400 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK2_PRICE_ATTRIBUTE_ID 0x8401 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK3_PRICE_ATTRIBUTE_ID 0x8402 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK4_PRICE_ATTRIBUTE_ID 0x8403 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK5_PRICE_ATTRIBUTE_ID 0x8404 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK6_PRICE_ATTRIBUTE_ID 0x8405 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK7_PRICE_ATTRIBUTE_ID 0x8406 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK8_PRICE_ATTRIBUTE_ID 0x8407 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK9_PRICE_ATTRIBUTE_ID 0x8408 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK10_PRICE_ATTRIBUTE_ID 0x8409 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK11_PRICE_ATTRIBUTE_ID 0x840A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK12_PRICE_ATTRIBUTE_ID 0x840B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK13_PRICE_ATTRIBUTE_ID 0x840C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK14_PRICE_ATTRIBUTE_ID 0x840D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK15_PRICE_ATTRIBUTE_ID 0x840E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NO_TIER_BLOCK16_PRICE_ATTRIBUTE_ID 0x840F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK1_PRICE_ATTRIBUTE_ID 0x8410 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK2_PRICE_ATTRIBUTE_ID 0x8411 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK3_PRICE_ATTRIBUTE_ID 0x8412 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK4_PRICE_ATTRIBUTE_ID 0x8413 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK5_PRICE_ATTRIBUTE_ID 0x8414 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK6_PRICE_ATTRIBUTE_ID 0x8415 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK7_PRICE_ATTRIBUTE_ID 0x8416 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK8_PRICE_ATTRIBUTE_ID 0x8417 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK9_PRICE_ATTRIBUTE_ID 0x8418 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK10_PRICE_ATTRIBUTE_ID 0x8419 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK11_PRICE_ATTRIBUTE_ID 0x841A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK12_PRICE_ATTRIBUTE_ID 0x841B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK13_PRICE_ATTRIBUTE_ID 0x841C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK14_PRICE_ATTRIBUTE_ID 0x841D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK15_PRICE_ATTRIBUTE_ID 0x841E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER1_BLOCK16_PRICE_ATTRIBUTE_ID 0x841F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK1_PRICE_ATTRIBUTE_ID 0x8420 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK2_PRICE_ATTRIBUTE_ID 0x8421 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK3_PRICE_ATTRIBUTE_ID 0x8422 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK4_PRICE_ATTRIBUTE_ID 0x8423 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK5_PRICE_ATTRIBUTE_ID 0x8424 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK6_PRICE_ATTRIBUTE_ID 0x8425 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK7_PRICE_ATTRIBUTE_ID 0x8426 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK8_PRICE_ATTRIBUTE_ID 0x8427 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK9_PRICE_ATTRIBUTE_ID 0x8428 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK10_PRICE_ATTRIBUTE_ID 0x8429 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK11_PRICE_ATTRIBUTE_ID 0x842A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK12_PRICE_ATTRIBUTE_ID 0x842B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK13_PRICE_ATTRIBUTE_ID 0x842C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK14_PRICE_ATTRIBUTE_ID 0x842D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK15_PRICE_ATTRIBUTE_ID 0x842E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER2_BLOCK16_PRICE_ATTRIBUTE_ID 0x842F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK1_PRICE_ATTRIBUTE_ID 0x8430 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK2_PRICE_ATTRIBUTE_ID 0x8431 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK3_PRICE_ATTRIBUTE_ID 0x8432 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK4_PRICE_ATTRIBUTE_ID 0x8433 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK5_PRICE_ATTRIBUTE_ID 0x8434 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK6_PRICE_ATTRIBUTE_ID 0x8435 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK7_PRICE_ATTRIBUTE_ID 0x8436 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK8_PRICE_ATTRIBUTE_ID 0x8437 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK9_PRICE_ATTRIBUTE_ID 0x8438 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK10_PRICE_ATTRIBUTE_ID 0x8439 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK11_PRICE_ATTRIBUTE_ID 0x843A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK12_PRICE_ATTRIBUTE_ID 0x843B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK13_PRICE_ATTRIBUTE_ID 0x843C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK14_PRICE_ATTRIBUTE_ID 0x843D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK15_PRICE_ATTRIBUTE_ID 0x843E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER3_BLOCK16_PRICE_ATTRIBUTE_ID 0x843F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK1_PRICE_ATTRIBUTE_ID 0x8440 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK2_PRICE_ATTRIBUTE_ID 0x8441 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK3_PRICE_ATTRIBUTE_ID 0x8442 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK4_PRICE_ATTRIBUTE_ID 0x8443 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK5_PRICE_ATTRIBUTE_ID 0x8444 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK6_PRICE_ATTRIBUTE_ID 0x8445 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK7_PRICE_ATTRIBUTE_ID 0x8446 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK8_PRICE_ATTRIBUTE_ID 0x8447 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK9_PRICE_ATTRIBUTE_ID 0x8448 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK10_PRICE_ATTRIBUTE_ID 0x8449 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK11_PRICE_ATTRIBUTE_ID 0x844A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK12_PRICE_ATTRIBUTE_ID 0x844B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK13_PRICE_ATTRIBUTE_ID 0x844C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK14_PRICE_ATTRIBUTE_ID 0x844D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK15_PRICE_ATTRIBUTE_ID 0x844E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER4_BLOCK16_PRICE_ATTRIBUTE_ID 0x844F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK1_PRICE_ATTRIBUTE_ID 0x8450 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK2_PRICE_ATTRIBUTE_ID 0x8451 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK3_PRICE_ATTRIBUTE_ID 0x8452 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK4_PRICE_ATTRIBUTE_ID 0x8453 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK5_PRICE_ATTRIBUTE_ID 0x8454 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK6_PRICE_ATTRIBUTE_ID 0x8455 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK7_PRICE_ATTRIBUTE_ID 0x8456 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK8_PRICE_ATTRIBUTE_ID 0x8457 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK9_PRICE_ATTRIBUTE_ID 0x8458 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK10_PRICE_ATTRIBUTE_ID 0x8459 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK11_PRICE_ATTRIBUTE_ID 0x845A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK12_PRICE_ATTRIBUTE_ID 0x845B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK13_PRICE_ATTRIBUTE_ID 0x845C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK14_PRICE_ATTRIBUTE_ID 0x845D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK15_PRICE_ATTRIBUTE_ID 0x845E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER5_BLOCK16_PRICE_ATTRIBUTE_ID 0x845F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK1_PRICE_ATTRIBUTE_ID 0x8460 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK2_PRICE_ATTRIBUTE_ID 0x8461 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK3_PRICE_ATTRIBUTE_ID 0x8462 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK4_PRICE_ATTRIBUTE_ID 0x8463 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK5_PRICE_ATTRIBUTE_ID 0x8464 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK6_PRICE_ATTRIBUTE_ID 0x8465 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK7_PRICE_ATTRIBUTE_ID 0x8466 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK8_PRICE_ATTRIBUTE_ID 0x8467 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK9_PRICE_ATTRIBUTE_ID 0x8468 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK10_PRICE_ATTRIBUTE_ID 0x8469 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK11_PRICE_ATTRIBUTE_ID 0x846A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK12_PRICE_ATTRIBUTE_ID 0x846B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK13_PRICE_ATTRIBUTE_ID 0x846C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK14_PRICE_ATTRIBUTE_ID 0x846D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK15_PRICE_ATTRIBUTE_ID 0x846E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER6_BLOCK16_PRICE_ATTRIBUTE_ID 0x846F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK1_PRICE_ATTRIBUTE_ID 0x8470 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK2_PRICE_ATTRIBUTE_ID 0x8471 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK3_PRICE_ATTRIBUTE_ID 0x8472 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK4_PRICE_ATTRIBUTE_ID 0x8473 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK5_PRICE_ATTRIBUTE_ID 0x8474 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK6_PRICE_ATTRIBUTE_ID 0x8475 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK7_PRICE_ATTRIBUTE_ID 0x8476 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK8_PRICE_ATTRIBUTE_ID 0x8477 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK9_PRICE_ATTRIBUTE_ID 0x8478 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK10_PRICE_ATTRIBUTE_ID 0x8479 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK11_PRICE_ATTRIBUTE_ID 0x847A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK12_PRICE_ATTRIBUTE_ID 0x847B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK13_PRICE_ATTRIBUTE_ID 0x847C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK14_PRICE_ATTRIBUTE_ID 0x847D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK15_PRICE_ATTRIBUTE_ID 0x847E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER7_BLOCK16_PRICE_ATTRIBUTE_ID 0x847F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK1_PRICE_ATTRIBUTE_ID 0x8480 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK2_PRICE_ATTRIBUTE_ID 0x8481 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK3_PRICE_ATTRIBUTE_ID 0x8482 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK4_PRICE_ATTRIBUTE_ID 0x8483 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK5_PRICE_ATTRIBUTE_ID 0x8484 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK6_PRICE_ATTRIBUTE_ID 0x8485 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK7_PRICE_ATTRIBUTE_ID 0x8486 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK8_PRICE_ATTRIBUTE_ID 0x8487 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK9_PRICE_ATTRIBUTE_ID 0x8488 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK10_PRICE_ATTRIBUTE_ID 0x8489 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK11_PRICE_ATTRIBUTE_ID 0x848A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK12_PRICE_ATTRIBUTE_ID 0x848B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK13_PRICE_ATTRIBUTE_ID 0x848C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK14_PRICE_ATTRIBUTE_ID 0x848D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK15_PRICE_ATTRIBUTE_ID 0x848E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER8_BLOCK16_PRICE_ATTRIBUTE_ID 0x848F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK1_PRICE_ATTRIBUTE_ID 0x8490 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK2_PRICE_ATTRIBUTE_ID 0x8491 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK3_PRICE_ATTRIBUTE_ID 0x8492 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK4_PRICE_ATTRIBUTE_ID 0x8493 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK5_PRICE_ATTRIBUTE_ID 0x8494 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK6_PRICE_ATTRIBUTE_ID 0x8495 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK7_PRICE_ATTRIBUTE_ID 0x8496 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK8_PRICE_ATTRIBUTE_ID 0x8497 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK9_PRICE_ATTRIBUTE_ID 0x8498 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK10_PRICE_ATTRIBUTE_ID 0x8499 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK11_PRICE_ATTRIBUTE_ID 0x849A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK12_PRICE_ATTRIBUTE_ID 0x849B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK13_PRICE_ATTRIBUTE_ID 0x849C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK14_PRICE_ATTRIBUTE_ID 0x849D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK15_PRICE_ATTRIBUTE_ID 0x849E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER9_BLOCK16_PRICE_ATTRIBUTE_ID 0x849F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK1_PRICE_ATTRIBUTE_ID 0x84A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK2_PRICE_ATTRIBUTE_ID 0x84A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK3_PRICE_ATTRIBUTE_ID 0x84A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK4_PRICE_ATTRIBUTE_ID 0x84A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK5_PRICE_ATTRIBUTE_ID 0x84A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK6_PRICE_ATTRIBUTE_ID 0x84A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK7_PRICE_ATTRIBUTE_ID 0x84A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK8_PRICE_ATTRIBUTE_ID 0x84A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK9_PRICE_ATTRIBUTE_ID 0x84A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK10_PRICE_ATTRIBUTE_ID 0x84A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK11_PRICE_ATTRIBUTE_ID 0x84AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK12_PRICE_ATTRIBUTE_ID 0x84AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK13_PRICE_ATTRIBUTE_ID 0x84AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK14_PRICE_ATTRIBUTE_ID 0x84AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK15_PRICE_ATTRIBUTE_ID 0x84AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER10_BLOCK16_PRICE_ATTRIBUTE_ID 0x84AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK1_PRICE_ATTRIBUTE_ID 0x84B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK2_PRICE_ATTRIBUTE_ID 0x84B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK3_PRICE_ATTRIBUTE_ID 0x84B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK4_PRICE_ATTRIBUTE_ID 0x84B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK5_PRICE_ATTRIBUTE_ID 0x84B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK6_PRICE_ATTRIBUTE_ID 0x84B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK7_PRICE_ATTRIBUTE_ID 0x84B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK8_PRICE_ATTRIBUTE_ID 0x84B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK9_PRICE_ATTRIBUTE_ID 0x84B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK10_PRICE_ATTRIBUTE_ID 0x84B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK11_PRICE_ATTRIBUTE_ID 0x84BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK12_PRICE_ATTRIBUTE_ID 0x84BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK13_PRICE_ATTRIBUTE_ID 0x84BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK14_PRICE_ATTRIBUTE_ID 0x84BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK15_PRICE_ATTRIBUTE_ID 0x84BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER11_BLOCK16_PRICE_ATTRIBUTE_ID 0x84BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK1_PRICE_ATTRIBUTE_ID 0x84C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK2_PRICE_ATTRIBUTE_ID 0x84C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK3_PRICE_ATTRIBUTE_ID 0x84C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK4_PRICE_ATTRIBUTE_ID 0x84C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK5_PRICE_ATTRIBUTE_ID 0x84C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK6_PRICE_ATTRIBUTE_ID 0x84C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK7_PRICE_ATTRIBUTE_ID 0x84C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK8_PRICE_ATTRIBUTE_ID 0x84C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK9_PRICE_ATTRIBUTE_ID 0x84C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK10_PRICE_ATTRIBUTE_ID 0x84C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK11_PRICE_ATTRIBUTE_ID 0x84CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK12_PRICE_ATTRIBUTE_ID 0x84CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK13_PRICE_ATTRIBUTE_ID 0x84CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK14_PRICE_ATTRIBUTE_ID 0x84CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK15_PRICE_ATTRIBUTE_ID 0x84CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER12_BLOCK16_PRICE_ATTRIBUTE_ID 0x84CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK1_PRICE_ATTRIBUTE_ID 0x84D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK2_PRICE_ATTRIBUTE_ID 0x84D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK3_PRICE_ATTRIBUTE_ID 0x84D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK4_PRICE_ATTRIBUTE_ID 0x84D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK5_PRICE_ATTRIBUTE_ID 0x84D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK6_PRICE_ATTRIBUTE_ID 0x84D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK7_PRICE_ATTRIBUTE_ID 0x84D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK8_PRICE_ATTRIBUTE_ID 0x84D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK9_PRICE_ATTRIBUTE_ID 0x84D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK10_PRICE_ATTRIBUTE_ID 0x84D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK11_PRICE_ATTRIBUTE_ID 0x84DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK12_PRICE_ATTRIBUTE_ID 0x84DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK13_PRICE_ATTRIBUTE_ID 0x84DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK14_PRICE_ATTRIBUTE_ID 0x84DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK15_PRICE_ATTRIBUTE_ID 0x84DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER13_BLOCK16_PRICE_ATTRIBUTE_ID 0x84DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK1_PRICE_ATTRIBUTE_ID 0x84E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK2_PRICE_ATTRIBUTE_ID 0x84E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK3_PRICE_ATTRIBUTE_ID 0x84E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK4_PRICE_ATTRIBUTE_ID 0x84E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK5_PRICE_ATTRIBUTE_ID 0x84E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK6_PRICE_ATTRIBUTE_ID 0x84E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK7_PRICE_ATTRIBUTE_ID 0x84E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK8_PRICE_ATTRIBUTE_ID 0x84E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK9_PRICE_ATTRIBUTE_ID 0x84E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK10_PRICE_ATTRIBUTE_ID 0x84E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK11_PRICE_ATTRIBUTE_ID 0x84EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK12_PRICE_ATTRIBUTE_ID 0x84EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK13_PRICE_ATTRIBUTE_ID 0x84EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK14_PRICE_ATTRIBUTE_ID 0x84ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK15_PRICE_ATTRIBUTE_ID 0x84EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER14_BLOCK16_PRICE_ATTRIBUTE_ID 0x84EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK1_PRICE_ATTRIBUTE_ID 0x84F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK2_PRICE_ATTRIBUTE_ID 0x84F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK3_PRICE_ATTRIBUTE_ID 0x84F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK4_PRICE_ATTRIBUTE_ID 0x84F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK5_PRICE_ATTRIBUTE_ID 0x84F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK6_PRICE_ATTRIBUTE_ID 0x84F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK7_PRICE_ATTRIBUTE_ID 0x84F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK8_PRICE_ATTRIBUTE_ID 0x84F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK9_PRICE_ATTRIBUTE_ID 0x84F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK10_PRICE_ATTRIBUTE_ID 0x84F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK11_PRICE_ATTRIBUTE_ID 0x84FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK12_PRICE_ATTRIBUTE_ID 0x84FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK13_PRICE_ATTRIBUTE_ID 0x84FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK14_PRICE_ATTRIBUTE_ID 0x84FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK15_PRICE_ATTRIBUTE_ID 0x84FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER15_BLOCK16_PRICE_ATTRIBUTE_ID 0x84FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER16_ATTRIBUTE_ID 0x850F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER17_ATTRIBUTE_ID 0x8510 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER18_ATTRIBUTE_ID 0x8511 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER19_ATTRIBUTE_ID 0x8512 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER20_ATTRIBUTE_ID 0x8513 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER21_ATTRIBUTE_ID 0x8514 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER22_ATTRIBUTE_ID 0x8515 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER23_ATTRIBUTE_ID 0x8516 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER24_ATTRIBUTE_ID 0x8517 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER25_ATTRIBUTE_ID 0x8518 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER26_ATTRIBUTE_ID 0x8519 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER27_ATTRIBUTE_ID 0x851A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER28_ATTRIBUTE_ID 0x851B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER29_ATTRIBUTE_ID 0x851C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER30_ATTRIBUTE_ID 0x851D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER31_ATTRIBUTE_ID 0x851E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER32_ATTRIBUTE_ID 0x851F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER33_ATTRIBUTE_ID 0x8520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER34_ATTRIBUTE_ID 0x8521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER35_ATTRIBUTE_ID 0x8522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER36_ATTRIBUTE_ID 0x8523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER37_ATTRIBUTE_ID 0x8524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER38_ATTRIBUTE_ID 0x8525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER39_ATTRIBUTE_ID 0x8526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER40_ATTRIBUTE_ID 0x8527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER41_ATTRIBUTE_ID 0x8528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER42_ATTRIBUTE_ID 0x8529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER43_ATTRIBUTE_ID 0x852A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER44_ATTRIBUTE_ID 0x852B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER45_ATTRIBUTE_ID 0x852C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER46_ATTRIBUTE_ID 0x852D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER47_ATTRIBUTE_ID 0x852E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_PRICE_TIER48_ATTRIBUTE_ID 0x852F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TARIFF_LABEL_ATTRIBUTE_ID 0x8610 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NUMBER_OF_PRICE_TIERS_IN_USE_ATTRIBUTE_ID 0x8611 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_NUMBER_OF_BLOCK_THRESHOLDS_IN_USE_ATTRIBUTE_ID 0x8612 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TIER_BLOCK_MODE_ATTRIBUTE_ID 0x8613 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_TARIFF_RESOLUTION_PERIOD_ATTRIBUTE_ID 0x8615 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_ATTRIBUTE_ID 0x8625 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_UNIT_ATTRIBUTE_ID 0x8626 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CO2_TRAILING_DIGIT_ATTRIBUTE_ID 0x8627 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CURRENT_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8700 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_CURRENT_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8701 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_LAST_BILLING_PERIOD_START_ATTRIBUTE_ID 0x8702 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_RX_LAST_BILLING_PERIOD_DURATION_ATTRIBUTE_ID 0x8703 // Ver.: since se-1.2a-07-5356-19 #define ZCL_RX_LAST_BILLING_PERIOD_CONSOLIDATED_BILL_ATTRIBUTE_ID 0x8704 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PRICE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_PRICE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_PRICE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PRICE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Demand Response and Load Control // Cluster specification level: se-1.2b-15-0131-02 // Client attributes -#define ZCL_UTILITY_ENROLLMENT_GROUP_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_START_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_DURATION_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_DEVICE_CLASS_VALUE_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_UTILITY_ENROLLMENT_GROUP_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_START_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DURATION_RANDOMIZATION_MINUTES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_DEVICE_CLASS_VALUE_ATTRIBUTE_ID 0x0003 // Ver.: always #define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 @@ -2642,910 +2664,908 @@ #define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Simple Metering // Cluster specification level: se-1.2b-15-0131-02 // Client attributes -#define ZCL_FUNCTIONAL_NOTIFICATION_FLAGS_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_2_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_3_ATTRIBUTE_ID 0x0002 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_4_ATTRIBUTE_ID 0x0003 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_5_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_6_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_7_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NOTIFICATION_FLAGS_8_ATTRIBUTE_ID 0x0007 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FUNCTIONAL_NOTIFICATION_FLAGS_ATTRIBUTE_ID 0x0000 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_2_ATTRIBUTE_ID 0x0001 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_3_ATTRIBUTE_ID 0x0002 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_4_ATTRIBUTE_ID 0x0003 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_5_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_6_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_7_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NOTIFICATION_FLAGS_8_ATTRIBUTE_ID 0x0007 // Ver.: since se-1.2a-07-5356-19 #define ZCL_SIMPLE_METERING_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SIMPLE_METERING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CURRENT_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CURRENT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_DFT_SUMMATION_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_DAILY_FREEZE_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_POWER_FACTOR_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_READING_SNAP_SHOT_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_DEFAULT_UPDATE_PERIOD_ATTRIBUTE_ID 0x000A // Ver.: since se-1.1-07-5356-16 -#define ZCL_FAST_POLL_UPDATE_PERIOD_ATTRIBUTE_ID 0x000B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x000C // Ver.: since se-1.1-07-5356-16 -#define ZCL_DAILY_CONSUMPTION_TARGET_ATTRIBUTE_ID 0x000D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_BLOCK_ATTRIBUTE_ID 0x000E // Ver.: since se-1.1-07-5356-16 -#define ZCL_PROFILE_INTERVAL_PERIOD_ATTRIBUTE_ID 0x000F // Ver.: since se-1.1-07-5356-16 -#define ZCL_INTERVAL_READ_REPORTING_PERIOD_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.1-07-5356-16 -#define ZCL_PRESET_READING_TIME_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.1-07-5356-16 -#define ZCL_VOLUME_PER_REPORT_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.1-07-5356-16 -#define ZCL_FLOW_RESTRICTION_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.1-07-5356-16 -#define ZCL_SUPPLY_STATUS_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_INLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.1-07-5356-16 -#define ZCL_INLET_TEMPERATURE_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.1-07-5356-16 -#define ZCL_OUTLET_TEMPERATURE_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CONTROL_TEMPERATURE_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_INLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001B // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_BLOCK_PERIOD_CONSUMIPTION_DELIVERED_ATTRIBUTE_ID 0x001C // Ver.: since se-1.1b-07-5356-18 -#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_BLOCK_RECEIVED_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DFT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ACTIVE_REGISTER_TIER_DELIVERED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ACTIVE_REGISTER_TIER_RECEIVED_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LAST_BLOCK_SWITCH_TIME_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0103 // Ver.: always -#define ZCL_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0104 // Ver.: always -#define ZCL_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0105 // Ver.: always -#define ZCL_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0106 // Ver.: always -#define ZCL_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0107 // Ver.: always -#define ZCL_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0108 // Ver.: always -#define ZCL_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0109 // Ver.: always -#define ZCL_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010A // Ver.: always -#define ZCL_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010B // Ver.: always -#define ZCL_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CPP1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CPP2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_STATUS_ATTRIBUTE_ID 0x0200 // Ver.: always -#define ZCL_REMAINING_BATTERY_LIFE_ATTRIBUTE_ID 0x0201 // Ver.: since se-1.1-07-5356-16 -#define ZCL_HOURS_IN_OPERATION_ATTRIBUTE_ID 0x0202 // Ver.: since se-1.1-07-5356-16 -#define ZCL_HOURS_IN_FAULT_ATTRIBUTE_ID 0x0203 // Ver.: since se-1.1-07-5356-16 -#define ZCL_EXTENDED_STATUS_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_REMAINING_BATTERY_LIFE_IN_DAYS_ATTRIBUTE_ID 0x0205 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_METER_ID_ATTRIBUTE_ID 0x0206 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_AMBIENT_CONSUMPTION_INDICATOR_ATTRIBUTE_ID 0x0207 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0300 // Ver.: always -#define ZCL_MULTIPLIER_ATTRIBUTE_ID 0x0301 // Ver.: always -#define ZCL_DIVISOR_ATTRIBUTE_ID 0x0302 // Ver.: always -#define ZCL_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x0303 // Ver.: always -#define ZCL_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0304 // Ver.: always -#define ZCL_HISTORICAL_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0305 // Ver.: always -#define ZCL_METERING_DEVICE_TYPE_ATTRIBUTE_ID 0x0306 // Ver.: always -#define ZCL_SITE_ID_ATTRIBUTE_ID 0x0307 // Ver.: since se-1.1-07-5356-16 -#define ZCL_METER_SERIAL_NUMBER_ATTRIBUTE_ID 0x0308 // Ver.: since se-1.1-07-5356-16 -#define ZCL_ENERGY_CARRIER_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0309 // Ver.: since se-1.1-07-5356-16 -#define ZCL_ENERGY_CARRIER_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x030A // Ver.: since se-1.1-07-5356-16 -#define ZCL_ENERGY_CARRIER_DEMAND_FORMATTING_ATTRIBUTE_ID 0x030B // Ver.: since se-1.1-07-5356-16 -#define ZCL_TEMPERATURE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x030C // Ver.: since se-1.1-07-5356-16 -#define ZCL_TEMPERATURE_FORMATTING_ATTRIBUTE_ID 0x030D // Ver.: since se-1.1-07-5356-16 -#define ZCL_MODULE_SERIAL_NUMBER_ATTRIBUTE_ID 0x030E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_OPERATING_TARIFF_LABEL_DELIVERED_ATTRIBUTE_ID 0x030F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_OPERATING_TARIFF_LABEL_RECEIVED_ATTRIBUTE_ID 0x0310 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CUSTOMER_ID_NUMBER_ATTRIBUTE_ID 0x0311 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ALTERNATIVE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0312 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ALTERNATIVE_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0313 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ALTERNATIVE_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0314 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0400 // Ver.: always -#define ZCL_CURRENT_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0401 // Ver.: always -#define ZCL_CURRENT_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0402 // Ver.: always -#define ZCL_PREVIOUS_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0403 // Ver.: always -#define ZCL_PREVIOUS_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0404 // Ver.: always -#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_DELIVERED_ATTRIBUTE_ID 0x0405 // Ver.: always -#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0406 // Ver.: always -#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0407 // Ver.: always -#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0408 // Ver.: always -#define ZCL_CURRENT_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0409 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040A // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x040B // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040D // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x040F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0410 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0411 // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0412 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_MONTH_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0413 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_MONTH_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0414 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_YEAR_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0415 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_YEAR_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0416 // Ver.: since se-1.1-07-5356-16 -#define ZCL_PREVIOUS_DAY2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0420 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0421 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0422 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0423 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0424 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0425 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0426 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0427 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0428 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0429 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0430 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0431 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0432 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0433 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0434 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0435 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0436 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0437 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0438 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0439 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x043A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x043B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0440 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0441 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0442 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0443 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0444 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0445 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0446 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0447 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0448 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0449 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0450 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0451 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0452 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0453 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0454 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0455 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0456 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0457 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0458 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0459 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x045A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x045B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_METERING_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x045C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x045D // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x045E // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x045F // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0460 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0461 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0462 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0463 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0464 // Ver.: since se-1.4-17-05019-001 -#define ZCL_MAX_NUMBER_OF_PERIODS_DELIVERED_ATTRIBUTE_ID 0x0500 // Ver.: always -#define ZCL_CURRENT_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0600 // Ver.: always -#define ZCL_DEMAND_LIMIT_ATTRIBUTE_ID 0x0601 // Ver.: always -#define ZCL_DEMAND_INTEGRATION_PERIOD_ATTRIBUTE_ID 0x0602 // Ver.: always -#define ZCL_NUMBER_OF_DEMAND_SUBINTERVALS_ATTRIBUTE_ID 0x0603 // Ver.: always -#define ZCL_DEMAND_LIMIT_ARM_DURATION_IN_MINUTES_ATTRIBUTE_ID 0x0604 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LOAD_LIMIT_SUPPLY_STATE_ATTRIBUTE_ID 0x0605 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LOAD_LIMIT_COUNTER_ATTRIBUTE_ID 0x0606 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SUPPLY_TAMPER_STATE_ATTRIBUTE_ID 0x0607 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SUPPLY_DEPLETION_STATE_ATTRIBUTE_ID 0x0608 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SUPPLY_UNCONTROLLED_FLOW_STATE_ATTRIBUTE_ID 0x0609 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0705 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0706 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0707 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0708 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0709 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0710 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0711 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0712 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0713 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0714 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0715 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0716 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0717 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0718 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0719 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0720 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0721 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0722 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0723 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0724 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0725 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0726 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0727 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0728 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0729 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0730 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0731 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0732 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0733 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0734 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0735 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0736 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0737 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0738 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0739 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0740 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0741 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0742 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0743 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0744 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0745 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0746 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0747 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0748 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0749 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0750 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0751 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0752 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0753 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0754 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0755 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0756 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0757 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0758 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0759 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0760 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0761 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0762 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0763 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0764 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0765 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0766 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0767 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0768 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0769 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0770 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0771 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0772 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0773 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0774 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0775 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0776 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0777 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0778 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0779 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0780 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0781 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0782 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0783 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0784 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0785 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0786 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0787 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0788 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0789 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0790 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0791 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0792 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0793 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0794 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0795 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0796 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0797 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0798 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0799 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079A // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079B // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079C // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079D // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079E // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079F // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AD // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AF // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BD // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BF // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CD // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CF // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DD // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DF // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07ED // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EF // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F0 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F1 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F2 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F3 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F4 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F5 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F6 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F7 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F8 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F9 // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FA // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FB // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FC // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FD // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FE // Ver.: since se-1.1-07-5356-16 -#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FF // Ver.: since se-1.1-07-5356-16 -#define ZCL_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.1-07-5356-16 -#define ZCL_ELECTRICITY_ALARM_MASK_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.1-07-5356-16 -#define ZCL_GENERIC_FLOW_PRESSURE_ALARM_MASK_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.1-07-5356-16 -#define ZCL_WATER_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0803 // Ver.: since se-1.1-07-5356-16 -#define ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0804 // Ver.: since se-1.1-07-5356-16 -#define ZCL_GAS_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0805 // Ver.: since se-1.1-07-5356-16 -#define ZCL_METERING_EXTENDED_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0806 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_METERING_MANUFACTURE_ALARM_MASK_ATTRIBUTE_ID 0x0807 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0900 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0901 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0902 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0903 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0904 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0905 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0906 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0907 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0908 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0909 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0910 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0911 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0912 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0913 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0914 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0915 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0916 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0917 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0918 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0919 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0920 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0921 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0922 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0923 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0924 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0925 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0926 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0927 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0928 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0929 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0930 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0931 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0932 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0933 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0934 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0935 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0936 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0937 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0938 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0939 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0940 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0941 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0942 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0943 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0944 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0945 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0946 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0947 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0948 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0949 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0950 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0951 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0952 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0953 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0954 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0955 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0956 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0957 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0958 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0959 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0960 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0961 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0962 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0963 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0964 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0965 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0966 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0967 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0968 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0969 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0970 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0971 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0972 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0973 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0974 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0975 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0976 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0977 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0978 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0979 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0980 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0981 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0982 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0983 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0984 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0985 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0986 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0987 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0988 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0989 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0990 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0991 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0992 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0993 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0994 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0995 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0996 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0997 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0998 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0999 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09ED // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F0 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F1 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F2 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F3 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F4 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F5 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F6 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F7 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F8 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F9 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FA // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FB // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FC // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FD // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FE // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FF // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_TO_DATE_DELIVERED_ATTRIBUTE_ID 0x0A00 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_TO_DATE_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A01 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROJECTED_BILL_DELIVERED_ATTRIBUTE_ID 0x0A02 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROJECTED_BILL_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A03 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_DELIVERED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A04 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_TO_DATE_RECEIVED_ATTRIBUTE_ID 0x0A10 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_TO_DATE_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A11 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROJECTED_BILL_RECEIVED_ATTRIBUTE_ID 0x0A12 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROJECTED_BILL_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A13 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_BILL_RECEIVED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A14 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROPOSED_CHANGE_SUPPLY_IMPLEMENTATION_TIME_ATTRIBUTE_ID 0x0B00 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PROPOSED_CHANGE_SUPPLY_STATUS_ATTRIBUTE_ID 0x0B01 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_UNCONTROLLED_FLOW_THESHOLD_ATTRIBUTE_ID 0x0B10 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_UNCONTROLLED_FLOW_THESHOLD_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0B11 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_UNCONTROLLED_FLOW_MULTIPLIER_ATTRIBUTE_ID 0x0B12 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_UNCONTROLLED_FLOW_DIVISOR_ATTRIBUTE_ID 0x0B13 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_FLOW_STABILIZATION_PERIOD_ATTRIBUTE_ID 0x0B14 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_FLOW_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0B15 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ALTERNATIVE_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0C00 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C01 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C02 // Ver.: always -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C03 // Ver.: always -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C04 // Ver.: always +#define ZCL_CURRENT_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_DFT_SUMMATION_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_DAILY_FREEZE_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_POWER_FACTOR_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_READING_SNAP_SHOT_TIME_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_CURRENT_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_DEFAULT_UPDATE_PERIOD_ATTRIBUTE_ID 0x000A // Ver.: since se-1.1-07-5356-16 +#define ZCL_FAST_POLL_UPDATE_PERIOD_ATTRIBUTE_ID 0x000B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x000C // Ver.: since se-1.1-07-5356-16 +#define ZCL_DAILY_CONSUMPTION_TARGET_ATTRIBUTE_ID 0x000D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_BLOCK_ATTRIBUTE_ID 0x000E // Ver.: since se-1.1-07-5356-16 +#define ZCL_PROFILE_INTERVAL_PERIOD_ATTRIBUTE_ID 0x000F // Ver.: since se-1.1-07-5356-16 +#define ZCL_INTERVAL_READ_REPORTING_PERIOD_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PRESET_READING_TIME_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.1-07-5356-16 +#define ZCL_VOLUME_PER_REPORT_ATTRIBUTE_ID 0x0012 // Ver.: since se-1.1-07-5356-16 +#define ZCL_FLOW_RESTRICTION_ATTRIBUTE_ID 0x0013 // Ver.: since se-1.1-07-5356-16 +#define ZCL_SUPPLY_STATUS_ATTRIBUTE_ID 0x0014 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_INLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0015 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION_ATTRIBUTE_ID 0x0016 // Ver.: since se-1.1-07-5356-16 +#define ZCL_INLET_TEMPERATURE_ATTRIBUTE_ID 0x0017 // Ver.: since se-1.1-07-5356-16 +#define ZCL_OUTLET_TEMPERATURE_ATTRIBUTE_ID 0x0018 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CONTROL_TEMPERATURE_ATTRIBUTE_ID 0x0019 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_INLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_OUTLET_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x001B // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_BLOCK_PERIOD_CONSUMIPTION_DELIVERED_ATTRIBUTE_ID 0x001C // Ver.: since se-1.1b-07-5356-18 +#define ZCL_CURRENT_BLOCK_PERIOD_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x001D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_BLOCK_RECEIVED_ATTRIBUTE_ID 0x001E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DFT_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x001F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACTIVE_REGISTER_TIER_DELIVERED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACTIVE_REGISTER_TIER_RECEIVED_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LAST_BLOCK_SWITCH_TIME_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x010E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x010F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0110 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0111 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0112 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0114 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0115 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0116 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0117 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0118 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0119 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x011E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x011F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0120 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0121 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0122 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0124 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0125 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0126 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0127 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0128 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0129 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x012E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x012F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0130 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0131 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0132 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0134 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0135 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0136 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0137 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0138 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0139 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x013E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x013F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0140 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0141 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0142 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0144 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0145 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0146 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0147 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0148 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0149 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x014E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x014F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0150 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0151 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0152 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0153 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0154 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0155 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0156 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0157 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0158 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0159 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x015E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x015F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x01FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_STATUS_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_REMAINING_BATTERY_LIFE_ATTRIBUTE_ID 0x0201 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HOURS_IN_OPERATION_ATTRIBUTE_ID 0x0202 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HOURS_IN_FAULT_ATTRIBUTE_ID 0x0203 // Ver.: since se-1.1-07-5356-16 +#define ZCL_EXTENDED_STATUS_ATTRIBUTE_ID 0x0204 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_REMAINING_BATTERY_LIFE_IN_DAYS_ATTRIBUTE_ID 0x0205 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_METER_ID_ATTRIBUTE_ID 0x0206 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_AMBIENT_CONSUMPTION_INDICATOR_ATTRIBUTE_ID 0x0207 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_MULTIPLIER_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_DIVISOR_ATTRIBUTE_ID 0x0302 // Ver.: always +#define ZCL_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x0303 // Ver.: always +#define ZCL_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0304 // Ver.: always +#define ZCL_HISTORICAL_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0305 // Ver.: always +#define ZCL_METERING_DEVICE_TYPE_ATTRIBUTE_ID 0x0306 // Ver.: always +#define ZCL_SITE_ID_ATTRIBUTE_ID 0x0307 // Ver.: since se-1.1-07-5356-16 +#define ZCL_METER_SERIAL_NUMBER_ATTRIBUTE_ID 0x0308 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0309 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_SUMMATION_FORMATTING_ATTRIBUTE_ID 0x030A // Ver.: since se-1.1-07-5356-16 +#define ZCL_ENERGY_CARRIER_DEMAND_FORMATTING_ATTRIBUTE_ID 0x030B // Ver.: since se-1.1-07-5356-16 +#define ZCL_TEMPERATURE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x030C // Ver.: since se-1.1-07-5356-16 +#define ZCL_TEMPERATURE_FORMATTING_ATTRIBUTE_ID 0x030D // Ver.: since se-1.1-07-5356-16 +#define ZCL_MODULE_SERIAL_NUMBER_ATTRIBUTE_ID 0x030E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OPERATING_TARIFF_LABEL_DELIVERED_ATTRIBUTE_ID 0x030F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OPERATING_TARIFF_LABEL_RECEIVED_ATTRIBUTE_ID 0x0310 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CUSTOMER_ID_NUMBER_ATTRIBUTE_ID 0x0311 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0312 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_DEMAND_FORMATTING_ATTRIBUTE_ID 0x0313 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0314 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_CURRENT_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_CURRENT_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_PREVIOUS_DAY_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_PREVIOUS_DAY_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_DELIVERED_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0406 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0407 // Ver.: always +#define ZCL_CURRENT_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0408 // Ver.: always +#define ZCL_CURRENT_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0409 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040A // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x040B // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x040C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040D // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_ATTRIBUTE_ID 0x040E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x040F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0410 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0411 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0412 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0413 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_MONTH_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0414 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MAX_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0415 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_YEAR_MIN_ENERGY_CARRIER_DEMAND_ATTRIBUTE_ID 0x0416 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PREVIOUS_DAY2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0420 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0421 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0422 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0423 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0424 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0425 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0426 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0427 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0428 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0429 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x042C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x042D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0430 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0431 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0432 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0433 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0434 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0435 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0436 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0437 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0438 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0439 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x043A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x043B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0440 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0441 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0442 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0443 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0444 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0445 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0446 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0447 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0448 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0449 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x044E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x044F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0450 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0451 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0452 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0453 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0454 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0455 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0456 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0457 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0458 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0459 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x045A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x045B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_METERING_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x045C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x045D // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x045E // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x045F // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0460 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0461 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0462 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0463 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0464 // Ver.: since se-1.4-17-05019-001 +#define ZCL_MAX_NUMBER_OF_PERIODS_DELIVERED_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_CURRENT_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_DEMAND_LIMIT_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_DEMAND_INTEGRATION_PERIOD_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_NUMBER_OF_DEMAND_SUBINTERVALS_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_DEMAND_LIMIT_ARM_DURATION_IN_MINUTES_ATTRIBUTE_ID 0x0604 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOAD_LIMIT_SUPPLY_STATE_ATTRIBUTE_ID 0x0605 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOAD_LIMIT_COUNTER_ATTRIBUTE_ID 0x0606 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_TAMPER_STATE_ATTRIBUTE_ID 0x0607 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_DEPLETION_STATE_ATTRIBUTE_ID 0x0608 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_UNCONTROLLED_FLOW_STATE_ATTRIBUTE_ID 0x0609 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0700 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0701 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0702 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0703 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0704 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0705 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0706 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0707 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0708 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0709 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x070F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0710 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0711 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0712 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0713 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0714 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0715 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0716 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0717 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0718 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0719 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x071F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0720 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0721 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0722 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0723 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0724 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0725 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0726 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0727 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0728 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0729 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x072F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0730 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0731 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0732 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0733 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0734 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0735 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0736 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0737 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0738 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0739 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x073F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0740 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0741 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0742 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0743 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0744 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0745 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0746 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0747 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0748 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0749 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x074F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0750 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0751 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0752 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0753 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0754 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0755 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0756 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0757 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0758 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0759 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x075F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0760 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0761 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0762 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0763 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0764 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0765 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0766 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0767 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0768 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0769 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x076F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0770 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0771 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0772 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0773 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0774 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0775 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0776 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0777 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0778 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0779 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x077F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0780 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0781 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0782 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0783 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0784 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0785 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0786 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0787 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0788 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0789 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x078F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0790 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0791 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0792 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0793 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0794 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0795 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0796 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0797 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0798 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x0799 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079A // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079B // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079C // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079D // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079E // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x079F // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07A9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07AF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07B9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07BF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07C9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07CF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07D9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07DF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07E9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07ED // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07EF // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F0 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F1 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F2 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F3 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F4 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F5 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F6 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F7 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F8 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07F9 // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FA // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FB // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FC // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FD // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FE // Ver.: since se-1.1-07-5356-16 +#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_DELIVERED_ATTRIBUTE_ID 0x07FF // Ver.: since se-1.1-07-5356-16 +#define ZCL_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0800 // Ver.: since se-1.1-07-5356-16 +#define ZCL_ELECTRICITY_ALARM_MASK_ATTRIBUTE_ID 0x0801 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GENERIC_FLOW_PRESSURE_ALARM_MASK_ATTRIBUTE_ID 0x0802 // Ver.: since se-1.1-07-5356-16 +#define ZCL_WATER_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0803 // Ver.: since se-1.1-07-5356-16 +#define ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0804 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GAS_SPECIFIC_ALARM_MASK_ATTRIBUTE_ID 0x0805 // Ver.: since se-1.1-07-5356-16 +#define ZCL_METERING_EXTENDED_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0806 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_METERING_MANUFACTURE_ALARM_MASK_ATTRIBUTE_ID 0x0807 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0900 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0901 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0902 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0903 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0904 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0905 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0906 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0907 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0908 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0909 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_NO_TIER_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x090F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0910 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0911 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0912 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0913 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0914 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0915 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0916 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0917 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0918 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0919 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER1_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x091F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0920 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0921 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0922 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0923 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0924 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0925 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0926 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0927 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0928 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0929 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER2_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x092F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0930 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0931 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0932 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0933 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0934 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0935 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0936 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0937 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0938 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0939 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER3_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x093F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0940 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0941 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0942 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0943 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0944 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0945 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0946 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0947 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0948 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0949 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER4_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x094F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0950 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0951 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0952 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0953 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0954 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0955 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0956 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0957 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0958 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0959 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER5_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x095F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0960 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0961 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0962 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0963 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0964 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0965 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0966 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0967 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0968 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0969 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER6_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x096F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0970 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0971 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0972 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0973 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0974 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0975 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0976 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0977 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0978 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0979 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER7_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x097F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0980 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0981 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0982 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0983 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0984 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0985 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0986 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0987 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0988 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0989 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER8_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x098F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0990 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0991 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0992 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0993 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0994 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0995 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0996 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0997 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0998 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x0999 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER9_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x099F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09A9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER10_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09AF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09B9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER11_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09BF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09C9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER12_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09CF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09D9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER13_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09DF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09E9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09ED // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER14_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09EF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK1_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F0 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK2_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F1 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK3_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F2 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK4_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F3 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK5_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F4 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK6_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F5 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK7_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F6 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK8_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F7 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK9_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F8 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK10_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09F9 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK11_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FA // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK12_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FB // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK13_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FC // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK14_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FD // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK15_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FE // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_TIER15_BLOCK16_SUMMATION_RECEIVED_ATTRIBUTE_ID 0x09FF // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_DELIVERED_ATTRIBUTE_ID 0x0A00 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_DELIVERED_ATTRIBUTE_ID 0x0A02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_TIME_STAMP_DELIVERED_ATTRIBUTE_ID 0x0A03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_DELIVERED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_RECEIVED_ATTRIBUTE_ID 0x0A10 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_TO_DATE_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A11 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_RECEIVED_ATTRIBUTE_ID 0x0A12 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROJECTED_BILL_TIME_STAMP_RECEIVED_ATTRIBUTE_ID 0x0A13 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_BILL_RECEIVED_TRAILING_DIGIT_ATTRIBUTE_ID 0x0A14 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROPOSED_CHANGE_SUPPLY_IMPLEMENTATION_TIME_ATTRIBUTE_ID 0x0B00 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PROPOSED_CHANGE_SUPPLY_STATUS_ATTRIBUTE_ID 0x0B01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_THESHOLD_ATTRIBUTE_ID 0x0B10 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_THESHOLD_UNIT_OF_MEASURE_ATTRIBUTE_ID 0x0B11 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_MULTIPLIER_ATTRIBUTE_ID 0x0B12 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_UNCONTROLLED_FLOW_DIVISOR_ATTRIBUTE_ID 0x0B13 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FLOW_STABILIZATION_PERIOD_ATTRIBUTE_ID 0x0B14 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FLOW_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0B15 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ALTERNATIVE_INSTANTANEOUS_DEMAND_ATTRIBUTE_ID 0x0C00 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C01 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C02 // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C03 // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C04 // Ver.: always #define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_START_TIME_DELIVERED_ATTRIBUTE_ID 0x0C05 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0C06 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0C07 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0C08 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0C09 // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0A // Ver.: always -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_PRESSURE_ATTRIBUTE_ID 0x0C0B // Ver.: always -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0C // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0D // Ver.: always -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0E // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x0C0F // Ver.: always -#define ZCL_CURRENT_ALTERNATIVE_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0C10 // Ver.: always -#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C20 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C21 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C22 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C23 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C24 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C25 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C26 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C27 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C28 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C29 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C30 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C31 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C32 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C33 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C34 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C35 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C36 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C37 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C38 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C39 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C3A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C3B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C40 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C41 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C42 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C43 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C44 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C45 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C46 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C47 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C48 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C49 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C50 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C51 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C52 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C53 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C54 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C55 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C56 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C57 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C58 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C59 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C5A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C5B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C5C // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C5D // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C5E // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C5F // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C60 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C61 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C62 // Ver.: since se-1.4-17-05019-001 -#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C63 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_ACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D01 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_ACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D02 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_ACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D03 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_ACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D04 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_REACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D05 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_REACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D06 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_REACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D07 // Ver.: since se-1.4-17-05019-001 -#define ZCL_CURRENT_REACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D08 // Ver.: since se-1.4-17-05019-001 -#define ZCL_SIMPLE_METERING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SIMPLE_METERING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_START_TIME_RECEIVED_ATTRIBUTE_ID 0x0C06 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_DELIVERED_ATTRIBUTE_ID 0x0C07 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_PARTIAL_PROFILE_INTERVAL_VALUE_RECEIVED_ATTRIBUTE_ID 0x0C08 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_MAX_PRESSURE_ATTRIBUTE_ID 0x0C09 // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0A // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_PRESSURE_ATTRIBUTE_ID 0x0C0B // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MIN_PRESSURE_ATTRIBUTE_ID 0x0C0C // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0D // Ver.: always +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_ATTRIBUTE_ID 0x0C0E // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_MONTH_MAX_DEMAND_ATTRIBUTE_ID 0x0C0F // Ver.: always +#define ZCL_CURRENT_ALTERNATIVE_YEAR_MAX_DEMAND_ATTRIBUTE_ID 0x0C10 // Ver.: always +#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C20 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C21 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C22 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C23 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C24 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C25 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C26 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C27 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C28 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C29 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C2C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C2D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C30 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C31 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C32 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C33 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C34 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C35 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C36 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C37 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C38 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C39 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C3A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C3B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C40 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C41 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C42 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C43 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C44 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH2_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C45 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C46 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH3_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C47 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C48 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH4_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C49 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH5_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH6_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C4E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH7_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C4F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C50 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH8_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C51 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C52 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH9_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C53 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C54 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH10_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C55 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C56 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH11_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C57 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C58 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH12_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C59 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0C5A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH13_ALTERNATIVE_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0C5B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C5C // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C5D // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C5E // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C5F // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_ATTRIBUTE_ID 0x0C60 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_DELIVERED_TIME_ATTRIBUTE_ID 0x0C61 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_ATTRIBUTE_ID 0x0C62 // Ver.: since se-1.4-17-05019-001 +#define ZCL_PREVIOUS_DAY_ALTERNATIVE_MAX_DEMAND_RECEIVED_TIME_ATTRIBUTE_ID 0x0C63 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D01 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D02 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D03 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_ACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D04 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q1_ATTRIBUTE_ID 0x0D05 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q2_ATTRIBUTE_ID 0x0D06 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q3_ATTRIBUTE_ID 0x0D07 // Ver.: since se-1.4-17-05019-001 +#define ZCL_CURRENT_REACTIVE_SUMMATION_Q4_ATTRIBUTE_ID 0x0D08 // Ver.: since se-1.4-17-05019-001 +#define ZCL_SIMPLE_METERING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SIMPLE_METERING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Messaging // Cluster specification level: se-1.2b-15-0131-02 @@ -3558,7 +3578,6 @@ #define ZCL_MESSAGING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_MESSAGING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Tunneling // Cluster specification level: se-1.2b-15-0131-02 @@ -3567,11 +3586,10 @@ #define ZCL_TUNNELING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CLOSE_TUNNEL_TIMEOUT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CLOSE_TUNNEL_TIMEOUT_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_TUNNELING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_TUNNELING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Prepayment // Cluster specification level: se-1.2b-15-0131-02 @@ -3580,140 +3598,139 @@ #define ZCL_PREPAYMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PAYMENT_CONTROL_CONFIGURATION_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CREDIT_REMAINING_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_REMAINING_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CREDIT_STATUS_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CREDIT_REMAINING_TIMESTAMP_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_ACCUMULATED_DEBT_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_OVERALL_DEBT_CAP_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_EMERGENCY_CREDIT_LIMIT_ALLOWANCE_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_EMERGENCY_CREDIT_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOTAL_CREDIT_ADDED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_MAX_CREDIT_LIMIT_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_MAX_CREDIT_PER_TOP_UP_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_FRIENDLY_CREDIT_WARNING_ATTRIBUTE_ID 0x0030 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0031 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0032 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_INTERRUPT_SUSPEND_TIME_ATTRIBUTE_ID 0x0033 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_REMAINING_FRIENDLY_CREDIT_TIME_ATTRIBUTE_ID 0x0034 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_NEXT_FRIENDLY_CREDIT_PERIOD_ATTRIBUTE_ID 0x0035 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CUT_OFF_VALUE_ATTRIBUTE_ID 0x0040 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOKEN_CARRIER_ID_ATTRIBUTE_ID 0x0080 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOP_UP_DATE_TIME_1_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_TOP_UP_AMOUNT_1_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_TOP_UP_ORIGINATING_DEVICE_1_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_TOP_UP_CODE_1_ATTRIBUTE_ID 0x0103 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOP_UP_DATE_TIME_2_ATTRIBUTE_ID 0x0110 // Ver.: always -#define ZCL_TOP_UP_AMOUNT_2_ATTRIBUTE_ID 0x0111 // Ver.: always -#define ZCL_TOP_UP_ORIGINATING_DEVICE_2_ATTRIBUTE_ID 0x0112 // Ver.: always -#define ZCL_TOP_UP_CODE_2_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOP_UP_DATE_TIME_3_ATTRIBUTE_ID 0x0120 // Ver.: always -#define ZCL_TOP_UP_AMOUNT_3_ATTRIBUTE_ID 0x0121 // Ver.: always -#define ZCL_TOP_UP_ORIGINATING_DEVICE_3_ATTRIBUTE_ID 0x0122 // Ver.: always -#define ZCL_TOP_UP_CODE_3_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOP_UP_DATE_TIME_4_ATTRIBUTE_ID 0x0130 // Ver.: always -#define ZCL_TOP_UP_AMOUNT_4_ATTRIBUTE_ID 0x0131 // Ver.: always -#define ZCL_TOP_UP_ORIGINATING_DEVICE_4_ATTRIBUTE_ID 0x0132 // Ver.: always -#define ZCL_TOP_UP_CODE_4_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TOP_UP_DATE_TIME_5_ATTRIBUTE_ID 0x0140 // Ver.: always -#define ZCL_TOP_UP_AMOUNT_5_ATTRIBUTE_ID 0x0141 // Ver.: always -#define ZCL_TOP_UP_ORIGINATING_DEVICE_5_ATTRIBUTE_ID 0x0142 // Ver.: always -#define ZCL_TOP_UP_CODE_5_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_LABEL_1_ATTRIBUTE_ID 0x0210 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_AMOUNT_1_ATTRIBUTE_ID 0x0211 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_METHOD_1_ATTRIBUTE_ID 0x0212 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_START_TIME_1_ATTRIBUTE_ID 0x0213 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_1_ATTRIBUTE_ID 0x0214 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_FREQUENCY_1_ATTRIBUTE_ID 0x0216 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_AMOUNT_1_ATTRIBUTE_ID 0x0217 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_1_ATTRIBUTE_ID 0x0219 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_LABEL_2_ATTRIBUTE_ID 0x0220 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_AMOUNT_2_ATTRIBUTE_ID 0x0221 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_METHOD_2_ATTRIBUTE_ID 0x0222 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_START_TIME_2_ATTRIBUTE_ID 0x0223 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_2_ATTRIBUTE_ID 0x0224 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_FREQUENCY_2_ATTRIBUTE_ID 0x0226 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_AMOUNT_2_ATTRIBUTE_ID 0x0227 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_2_ATTRIBUTE_ID 0x0229 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_LABEL_3_ATTRIBUTE_ID 0x0230 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_AMOUNT_3_ATTRIBUTE_ID 0x0231 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_METHOD_3_ATTRIBUTE_ID 0x0232 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_START_TIME_3_ATTRIBUTE_ID 0x0233 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_3_ATTRIBUTE_ID 0x0234 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_FREQUENCY_3_ATTRIBUTE_ID 0x0236 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_AMOUNT_3_ATTRIBUTE_ID 0x0237 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_3_ATTRIBUTE_ID 0x0239 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAYMENT_ALARM_STATUS_ATTRIBUTE_ID 0x0400 // Ver.: since se-1.2a-07-5356-21 -#define ZCL_PREPAY_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0401 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAY_SWITCH_ALARM_MASK_ATTRIBUTE_ID 0x0402 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAY_EVENT_ALARM_MASK_ATTRIBUTE_ID 0x0403 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_HISTORICAL_COST_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0500 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONSUMPTION_UNIT_OF_MEASUREMENT_ATTRIBUTE_ID 0x0501 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENCY_SCALING_FACTOR_ATTRIBUTE_ID 0x0502 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAYMANT_CURRENCY_ATTRIBUTE_ID 0x0503 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0530 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0531 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0532 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0533 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0534 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0535 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0536 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0537 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0538 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0539 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x053A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x053B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0540 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0541 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0542 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0543 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0544 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0545 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0546 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0547 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0548 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0549 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054E // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0550 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0551 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0552 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0553 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PAYMENT_CONTROL_CONFIGURATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CREDIT_REMAINING_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_REMAINING_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CREDIT_STATUS_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CREDIT_REMAINING_TIMESTAMP_ATTRIBUTE_ID 0x0004 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_ACCUMULATED_DEBT_ATTRIBUTE_ID 0x0005 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_OVERALL_DEBT_CAP_ATTRIBUTE_ID 0x0006 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_LIMIT_ALLOWANCE_ATTRIBUTE_ID 0x0010 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_THRESHOLD_ATTRIBUTE_ID 0x0011 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOTAL_CREDIT_ADDED_ATTRIBUTE_ID 0x0020 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_MAX_CREDIT_LIMIT_ATTRIBUTE_ID 0x0021 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_MAX_CREDIT_PER_TOP_UP_ATTRIBUTE_ID 0x0022 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_FRIENDLY_CREDIT_WARNING_ATTRIBUTE_ID 0x0030 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0031 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0032 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_INTERRUPT_SUSPEND_TIME_ATTRIBUTE_ID 0x0033 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_REMAINING_FRIENDLY_CREDIT_TIME_ATTRIBUTE_ID 0x0034 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_NEXT_FRIENDLY_CREDIT_PERIOD_ATTRIBUTE_ID 0x0035 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CUT_OFF_VALUE_ATTRIBUTE_ID 0x0040 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOKEN_CARRIER_ID_ATTRIBUTE_ID 0x0080 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_1_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_1_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_1_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_TOP_UP_CODE_1_ATTRIBUTE_ID 0x0103 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_2_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_2_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_2_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_TOP_UP_CODE_2_ATTRIBUTE_ID 0x0113 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_3_ATTRIBUTE_ID 0x0120 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_3_ATTRIBUTE_ID 0x0121 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_3_ATTRIBUTE_ID 0x0122 // Ver.: always +#define ZCL_TOP_UP_CODE_3_ATTRIBUTE_ID 0x0123 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_4_ATTRIBUTE_ID 0x0130 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_4_ATTRIBUTE_ID 0x0131 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_4_ATTRIBUTE_ID 0x0132 // Ver.: always +#define ZCL_TOP_UP_CODE_4_ATTRIBUTE_ID 0x0133 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TOP_UP_DATE_TIME_5_ATTRIBUTE_ID 0x0140 // Ver.: always +#define ZCL_TOP_UP_AMOUNT_5_ATTRIBUTE_ID 0x0141 // Ver.: always +#define ZCL_TOP_UP_ORIGINATING_DEVICE_5_ATTRIBUTE_ID 0x0142 // Ver.: always +#define ZCL_TOP_UP_CODE_5_ATTRIBUTE_ID 0x0143 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_1_ATTRIBUTE_ID 0x0210 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_1_ATTRIBUTE_ID 0x0211 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_1_ATTRIBUTE_ID 0x0212 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_1_ATTRIBUTE_ID 0x0213 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_1_ATTRIBUTE_ID 0x0214 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_1_ATTRIBUTE_ID 0x0216 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_1_ATTRIBUTE_ID 0x0217 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_1_ATTRIBUTE_ID 0x0219 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_2_ATTRIBUTE_ID 0x0220 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_2_ATTRIBUTE_ID 0x0221 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_2_ATTRIBUTE_ID 0x0222 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_2_ATTRIBUTE_ID 0x0223 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_2_ATTRIBUTE_ID 0x0224 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_2_ATTRIBUTE_ID 0x0226 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_2_ATTRIBUTE_ID 0x0227 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_2_ATTRIBUTE_ID 0x0229 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_LABEL_3_ATTRIBUTE_ID 0x0230 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_AMOUNT_3_ATTRIBUTE_ID 0x0231 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_METHOD_3_ATTRIBUTE_ID 0x0232 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_START_TIME_3_ATTRIBUTE_ID 0x0233 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_COLLECTION_TIME_3_ATTRIBUTE_ID 0x0234 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_FREQUENCY_3_ATTRIBUTE_ID 0x0236 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_AMOUNT_3_ATTRIBUTE_ID 0x0237 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_DEBT_RECOVERY_TOP_UP_PERCENTAGE_3_ATTRIBUTE_ID 0x0239 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_ALARM_STATUS_ATTRIBUTE_ID 0x0400 // Ver.: since se-1.2a-07-5356-21 +#define ZCL_PREPAY_GENERIC_ALARM_MASK_ATTRIBUTE_ID 0x0401 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAY_SWITCH_ALARM_MASK_ATTRIBUTE_ID 0x0402 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAY_EVENT_ALARM_MASK_ATTRIBUTE_ID 0x0403 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_HISTORICAL_COST_CONSUMPTION_FORMATTING_ATTRIBUTE_ID 0x0500 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMPTION_UNIT_OF_MEASUREMENT_ATTRIBUTE_ID 0x0501 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENCY_SCALING_FACTOR_ATTRIBUTE_ID 0x0502 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMANT_CURRENCY_ATTRIBUTE_ID 0x0503 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x051E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x051F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0520 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0521 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0522 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0523 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0524 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0525 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0526 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0527 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0528 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0529 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x052C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_DAY_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x052D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0530 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0531 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0532 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0533 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0534 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0535 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0536 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0537 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0538 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0539 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x053A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_WEEK_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x053B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0540 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CURRENT_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0541 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0542 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0543 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0544 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_2_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0545 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0546 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_3_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0547 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0548 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_4_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0549 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_5_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_6_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x054E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_7_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x054F // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0550 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_8_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0551 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0552 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_9_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0553 // Ver.: since se-1.2a-07-5356-19 #define ZCL_PREVIOUS_MONTH_10_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0554 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_10_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0555 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_10_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0555 // Ver.: since se-1.2a-07-5356-19 #define ZCL_PREVIOUS_MONTH_11_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0556 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_11_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0557 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_11_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0557 // Ver.: since se-1.2a-07-5356-19 #define ZCL_PREVIOUS_MONTH_12_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x0558 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_12_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0559 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREVIOUS_MONTH_12_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x0559 // Ver.: since se-1.2a-07-5356-19 #define ZCL_PREVIOUS_MONTH_13_COST_CONSUMPTION_DELIVERED_ATTRIBUTE_ID 0x055A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREVIOUS_MONTH_13_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x055B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAYMENT_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x055C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PREPAYMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_PREPAYMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_PREVIOUS_MONTH_13_COST_CONSUMPTION_RECEIVED_ATTRIBUTE_ID 0x055B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_HISTORICAL_FREEZE_TIME_ATTRIBUTE_ID 0x055C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PREPAYMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_PREPAYMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Attribute types for cluster: Energy Management // Cluster specification level: se-1.2b-15-0131-02 @@ -3723,17 +3740,16 @@ #define ZCL_ENERGY_MANAGEMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LOAD_CONTROL_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_CURRENT_EVENT_ID_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CURRENT_EVENT_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_CONFORMANCE_LEVEL_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_MINIMUM_OFF_TIME_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_MINIMUM_ON_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_MINIMUM_CYCLE_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_LOAD_CONTROL_STATE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_CURRENT_EVENT_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CURRENT_EVENT_STATUS_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_CONFORMANCE_LEVEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_MINIMUM_OFF_TIME_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_MINIMUM_ON_TIME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_MINIMUM_CYCLE_PERIOD_ATTRIBUTE_ID 0x0006 // Ver.: always #define ZCL_ENERGY_MANAGEMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ENERGY_MANAGEMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Calendar // Cluster specification level: se-1.2b-15-0131-02 @@ -3742,483 +3758,481 @@ #define ZCL_CALENDAR_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_AUXILIARY_SWITCH_1_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_2_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_3_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_4_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_5_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_6_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_7_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_AUXILIARY_SWITCH_8_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_1_LABEL_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_2_LABEL_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_3_LABEL_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_4_LABEL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_5_LABEL_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_6_LABEL_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_7_LABEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_AUXILIARY_SWITCH_8_LABEL_ATTRIBUTE_ID 0x0007 // Ver.: always #define ZCL_CALENDAR_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_CALENDAR_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Device Management // Cluster specification level: se-1.2b-15-0131-02 // Client attributes -#define ZCL_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_RECEIVED_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_TOU_TARIFF_ACTIVATION_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_BLOCK_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_BLOCK_TOU_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_SINGLE_TARIFF_RATE_ACTIVATED_ATTRIBUTE_ID 0x0103 // Ver.: always -#define ZCL_ASYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0104 // Ver.: always -#define ZCL_SYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0105 // Ver.: always -#define ZCL_TARIFF_NOT_SUPPORTED_ATTRIBUTE_ID 0x0106 // Ver.: always -#define ZCL_PRICE_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0107 // Ver.: always -#define ZCL_CURRENCY_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0108 // Ver.: always -#define ZCL_CURRENCY_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0109 // Ver.: always -#define ZCL_PRICE_MATRIX_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010A // Ver.: always -#define ZCL_PRICE_MATRIX_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010B // Ver.: always -#define ZCL_TARIFF_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010C // Ver.: always -#define ZCL_TARIFF_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010D // Ver.: always -#define ZCL_PUBLISH_PRICE_RECEIVED_ATTRIBUTE_ID 0x01B0 // Ver.: always -#define ZCL_PUBLISH_PRICE_ACTIONED_ATTRIBUTE_ID 0x01B1 // Ver.: always -#define ZCL_PUBLISH_PRICE_CANCELLED_ATTRIBUTE_ID 0x01B2 // Ver.: always -#define ZCL_PUBLISH_PRICE_REJECTED_ATTRIBUTE_ID 0x01B3 // Ver.: always -#define ZCL_PUBLISH_TARIFF_INFO_RECEIVED_ATTRIBUTE_ID 0x01B4 // Ver.: always -#define ZCL_PUBLISH_TARIFF_INFO_ACTIONED_ATTRIBUTE_ID 0x01B5 // Ver.: always -#define ZCL_PUBLISH_TARIFF_INFO_CANCELLED_ATTRIBUTE_ID 0x01B6 // Ver.: always -#define ZCL_PUBLISH_TARIFF_INFO_REJECTED_ATTRIBUTE_ID 0x01B7 // Ver.: always -#define ZCL_PUBLISH_PRICE_MATRIX_RECEIVED_ATTRIBUTE_ID 0x01B8 // Ver.: always -#define ZCL_PUBLISH_PRICE_MATRIX_ACTIONED_ATTRIBUTE_ID 0x01B9 // Ver.: always -#define ZCL_PUBLISH_PRICE_MATRIX_CANCELLED_ATTRIBUTE_ID 0x01BA // Ver.: always -#define ZCL_PUBLISH_PRICE_MATRIX_REJECTED_ATTRIBUTE_ID 0x01BB // Ver.: always -#define ZCL_PUBLISH_BLOCK_THRESHOLDS_RECEIVED_ATTRIBUTE_ID 0x01BC // Ver.: always -#define ZCL_PUBLISH_BLOCK_THRESHOLDS_ACTIONED_ATTRIBUTE_ID 0x01BD // Ver.: always -#define ZCL_PUBLISH_BLOCK_THRESHOLDS_CANCELLED_ATTRIBUTE_ID 0x01BE // Ver.: always -#define ZCL_PUBLISH_BLOCK_THRESHOLDS_REJECTED_ATTRIBUTE_ID 0x01BF // Ver.: always -#define ZCL_PUBLISH_CALORIFIC_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C0 // Ver.: always -#define ZCL_PUBLISH_CALORIFIC_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C1 // Ver.: always -#define ZCL_PUBLISH_CALORIFIC_VALUE_CANCELLED_ATTRIBUTE_ID 0x01C2 // Ver.: always -#define ZCL_PUBLISH_CALORIFIC_VALUE_REJECTED_ATTRIBUTE_ID 0x01C3 // Ver.: always -#define ZCL_PUBLISH_CONVERSION_FACTOR_RECEIVED_ATTRIBUTE_ID 0x01C4 // Ver.: always -#define ZCL_PUBLISH_CONVERSION_FACTOR_ACTIONED_ATTRIBUTE_ID 0x01C5 // Ver.: always -#define ZCL_PUBLISH_CONVERSION_FACTOR_CANCELLED_ATTRIBUTE_ID 0x01C6 // Ver.: always -#define ZCL_PUBLISH_CONVERSION_FACTOR_REJECTED_ATTRIBUTE_ID 0x01C7 // Ver.: always -#define ZCL_PUBLISH_CO2_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C8 // Ver.: always -#define ZCL_PUBLISH_CO2_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C9 // Ver.: always -#define ZCL_PUBLISH_CO2_VALUE_CANCELLED_ATTRIBUTE_ID 0x01CA // Ver.: always -#define ZCL_PUBLISH_CO2_VALUE_REJECTED_ATTRIBUTE_ID 0x01CB // Ver.: always -#define ZCL_PUBLISH_CPP_EVENT_RECEIVED_ATTRIBUTE_ID 0x01CC // Ver.: always -#define ZCL_PUBLISH_CPP_EVENT_ACTIONED_ATTRIBUTE_ID 0x01CD // Ver.: always -#define ZCL_PUBLISH_CPP_EVENT_CANCELLED_ATTRIBUTE_ID 0x01CE // Ver.: always -#define ZCL_PUBLISH_CPP_EVENT_REJECTED_ATTRIBUTE_ID 0x01CF // Ver.: always -#define ZCL_PUBLISH_TIER_LABELS_RECEIVED_ATTRIBUTE_ID 0x01D0 // Ver.: always -#define ZCL_PUBLISH_TIER_LABELS_ACTIONED_ATTRIBUTE_ID 0x01D1 // Ver.: always -#define ZCL_PUBLISH_TIER_LABELS_CANCELLED_ATTRIBUTE_ID 0x01D2 // Ver.: always -#define ZCL_PUBLISH_TIER_LABELS_REJECTED_ATTRIBUTE_ID 0x01D3 // Ver.: always -#define ZCL_PUBLISH_BILLING_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01D4 // Ver.: always -#define ZCL_PUBLISH_BILLING_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01D5 // Ver.: always -#define ZCL_PUBLISH_BILLING_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01D6 // Ver.: always -#define ZCL_PUBLISH_BILLING_PERIOD_REJECTED_ATTRIBUTE_ID 0x01D7 // Ver.: always -#define ZCL_PUBLISH_CONSOLIDATED_BILL_RECEIVED_ATTRIBUTE_ID 0x01D8 // Ver.: always -#define ZCL_PUBLISH_CONSOLIDATED_BILL_ACTIONED_ATTRIBUTE_ID 0x01D9 // Ver.: always -#define ZCL_PUBLISH_CONSOLIDATED_BILL_CANCELLED_ATTRIBUTE_ID 0x01DA // Ver.: always -#define ZCL_PUBLISH_CONSOLIDATED_BILL_REJECTED_ATTRIBUTE_ID 0x01DB // Ver.: always -#define ZCL_PUBLISH_BLOCK_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01DC // Ver.: always -#define ZCL_PUBLISH_BLOCK_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01DD // Ver.: always -#define ZCL_PUBLISH_BLOCK_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01DE // Ver.: always -#define ZCL_PUBLISH_BLOCK_PERIOD_REJECTED_ATTRIBUTE_ID 0x01DF // Ver.: always -#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_RECEIVED_ATTRIBUTE_ID 0x01E0 // Ver.: always -#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_ACTIONED_ATTRIBUTE_ID 0x01E1 // Ver.: always -#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_CANCELLED_ATTRIBUTE_ID 0x01E2 // Ver.: always -#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_REJECTED_ATTRIBUTE_ID 0x01E3 // Ver.: always -#define ZCL_PUBLISH_CURRENCY_CONVERSION_RECEIVED_ATTRIBUTE_ID 0x01E4 // Ver.: always -#define ZCL_PUBLISH_CURRENCY_CONVERSION_ACTIONED_ATTRIBUTE_ID 0x01E5 // Ver.: always -#define ZCL_PUBLISH_CURRENCY_CONVERSION_CANCELLED_ATTRIBUTE_ID 0x01E6 // Ver.: always -#define ZCL_PUBLISH_CURRENCY_CONVERSION_REJECTED_ATTRIBUTE_ID 0x01E7 // Ver.: always -#define ZCL_CHECK_METER_ATTRIBUTE_ID 0x0200 // Ver.: always -#define ZCL_LOW_BATTERY_ATTRIBUTE_ID 0x0201 // Ver.: always -#define ZCL_TAMPER_DETECT_ATTRIBUTE_ID 0x0202 // Ver.: always -#define ZCL_DEVICE_MANAGEMENT_SUPPLY_STATUS_ATTRIBUTE_ID 0x0203 // Ver.: always -#define ZCL_SUPPLY_QUALITY_ATTRIBUTE_ID 0x0204 // Ver.: always -#define ZCL_LEAK_DETECT_ATTRIBUTE_ID 0x0205 // Ver.: always -#define ZCL_SERVICE_DISCONNECT_ATTRIBUTE_ID 0x0206 // Ver.: always -#define ZCL_REVERSE_FLOW_GENERAL_ATTRIBUTE_ID 0x0207 // Ver.: always -#define ZCL_METER_COVER_REMOVED_ATTRIBUTE_ID 0x0208 // Ver.: always -#define ZCL_METER_COVER_CLOSED_ATTRIBUTE_ID 0x0209 // Ver.: always -#define ZCL_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020A // Ver.: always -#define ZCL_NO_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020B // Ver.: always -#define ZCL_BATTERY_FAILURE_ATTRIBUTE_ID 0x020C // Ver.: always -#define ZCL_PROGRAM_MEMORY_ERROR_ATTRIBUTE_ID 0x020D // Ver.: always -#define ZCL_RAM_ERROR_ATTRIBUTE_ID 0x020E // Ver.: always -#define ZCL_NV_MEMORY_ERROR_ATTRIBUTE_ID 0x020F // Ver.: always -#define ZCL_LOW_VOLTAGE_L1_ATTRIBUTE_ID 0x0210 // Ver.: always -#define ZCL_HIGH_VOLTAGE_L1_ATTRIBUTE_ID 0x0211 // Ver.: always -#define ZCL_LOW_VOLTAGE_L2_ATTRIBUTE_ID 0x0212 // Ver.: always -#define ZCL_HIGH_VOLTAGE_L2_ATTRIBUTE_ID 0x0213 // Ver.: always -#define ZCL_LOW_VOLTAGE_L3_ATTRIBUTE_ID 0x0214 // Ver.: always -#define ZCL_HIGH_VOLTAGE_L3_ATTRIBUTE_ID 0x0215 // Ver.: always -#define ZCL_OVER_CURRENT_L1_ATTRIBUTE_ID 0x0216 // Ver.: always -#define ZCL_OVER_CURRENT_L2_ATTRIBUTE_ID 0x0217 // Ver.: always -#define ZCL_OVER_CURRENT_L3_ATTRIBUTE_ID 0x0218 // Ver.: always -#define ZCL_FREQUENCY_TOO_LOW_L1_ATTRIBUTE_ID 0x0219 // Ver.: always -#define ZCL_FREQUENCY_TOO_HIGH_L1_ATTRIBUTE_ID 0x021A // Ver.: always -#define ZCL_FREQUENCY_TOO_LOW_L2_ATTRIBUTE_ID 0x021B // Ver.: always -#define ZCL_FREQUENCY_TOO_HIGH_L2_ATTRIBUTE_ID 0x021C // Ver.: always -#define ZCL_FREQUENCY_TOO_LOW_L3_ATTRIBUTE_ID 0x021D // Ver.: always -#define ZCL_FREQUENCY_TOO_HIGH_L3_ATTRIBUTE_ID 0x021E // Ver.: always -#define ZCL_GROUND_FAULT_ATTRIBUTE_ID 0x021F // Ver.: always -#define ZCL_ELECTRIC_TAMPER_DETECT_ATTRIBUTE_ID 0x0220 // Ver.: always -#define ZCL_INCORRECT_POLARITY_ATTRIBUTE_ID 0x0221 // Ver.: always -#define ZCL_CURRENT_NO_VOLTAGE_ATTRIBUTE_ID 0x0222 // Ver.: always -#define ZCL_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0223 // Ver.: always -#define ZCL_OVER_VOLTAGE_ATTRIBUTE_ID 0x0224 // Ver.: always -#define ZCL_NORMAL_VOLTAGE_ATTRIBUTE_ID 0x0225 // Ver.: always -#define ZCL_PF_BELOW_THRESHOLD_ATTRIBUTE_ID 0x0226 // Ver.: always -#define ZCL_PF_ABOVE_THRESHOLD_ATTRIBUTE_ID 0x0227 // Ver.: always -#define ZCL_TERMINAL_COVER_REMOVED_ATTRIBUTE_ID 0x0228 // Ver.: always -#define ZCL_TERMINAL_COVER_CLOSED_ATTRIBUTE_ID 0x0229 // Ver.: always -#define ZCL_BURST_DETECT_ATTRIBUTE_ID 0x0230 // Ver.: always -#define ZCL_PRESSURE_TOO_LOW_ATTRIBUTE_ID 0x0231 // Ver.: always -#define ZCL_PRESSURE_TOO_HIGH_ATTRIBUTE_ID 0x0232 // Ver.: always -#define ZCL_FLOW_SENSOR_COMMUNICATION_ERROR_ATTRIBUTE_ID 0x0233 // Ver.: always -#define ZCL_FLOW_SENSOR_MEASUREMENT_FAULT_ATTRIBUTE_ID 0x0234 // Ver.: always -#define ZCL_FLOW_SENSOR_REVERSE_FLOW_ATTRIBUTE_ID 0x0235 // Ver.: always -#define ZCL_FLOW_SENSOR_AIR_DETECT_ATTRIBUTE_ID 0x0236 // Ver.: always -#define ZCL_PIPE_EMPTY_ATTRIBUTE_ID 0x0237 // Ver.: always -#define ZCL_INLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0250 // Ver.: always -#define ZCL_OUTLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0251 // Ver.: always -#define ZCL_REVERSE_FLOW_ATTRIBUTE_ID 0x0260 // Ver.: always -#define ZCL_TILT_TAMPER_ATTRIBUTE_ID 0x0261 // Ver.: always -#define ZCL_BATTERY_COVER_REMOVED_ATTRIBUTE_ID 0x0262 // Ver.: always -#define ZCL_BATTERY_COVER_CLOSED_ATTRIBUTE_ID 0x0263 // Ver.: always -#define ZCL_EXCESS_FLOW_ATTRIBUTE_ID 0x0264 // Ver.: always -#define ZCL_TILT_TAMPER_ENABLED_ATTRIBUTE_ID 0x0265 // Ver.: always -#define ZCL_MEASUREMENT_SYSTEM_ERROR_ATTRIBUTE_ID 0x0270 // Ver.: always -#define ZCL_WATCHDOG_ERROR_ATTRIBUTE_ID 0x0271 // Ver.: always -#define ZCL_SUPPLY_DISCONNECT_FAILURE_ATTRIBUTE_ID 0x0272 // Ver.: always -#define ZCL_SUPPLY_CONNECT_FAILURE_ATTRIBUTE_ID 0x0273 // Ver.: always -#define ZCL_MEASUREMENT_SOFTWARE_CHANGED_ATTRIBUTE_ID 0x0274 // Ver.: always -#define ZCL_DST_ENABLED_ATTRIBUTE_ID 0x0275 // Ver.: always -#define ZCL_DST_DISABLED_ATTRIBUTE_ID 0x0276 // Ver.: always -#define ZCL_CLOCK_ADJ_BACKWARD_ATTRIBUTE_ID 0x0277 // Ver.: always -#define ZCL_CLOCK_ADJ_FORWARD_ATTRIBUTE_ID 0x0278 // Ver.: always -#define ZCL_CLOCK_INVALID_ATTRIBUTE_ID 0x0279 // Ver.: always -#define ZCL_COMMUNICATION_ERROR_HAN_ATTRIBUTE_ID 0x027A // Ver.: always -#define ZCL_COMMUNICATION_OK_HAN_ATTRIBUTE_ID 0x027B // Ver.: always -#define ZCL_METER_FRAUD_ATTEMPT_ATTRIBUTE_ID 0x027C // Ver.: always -#define ZCL_POWER_LOSS_ATTRIBUTE_ID 0x027D // Ver.: always -#define ZCL_UNUSUAL_HAN_TRAFFIC_ATTRIBUTE_ID 0x027E // Ver.: always -#define ZCL_UNEXPECTED_CLOCK_CHANGE_ATTRIBUTE_ID 0x027F // Ver.: always -#define ZCL_COMMS_USING_UNAUTHENTICATED_COMPONENT_ATTRIBUTE_ID 0x0280 // Ver.: always -#define ZCL_METERING_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0281 // Ver.: always -#define ZCL_METERING_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0282 // Ver.: always -#define ZCL_UNEXPECTED_HW_RESET_ATTRIBUTE_ID 0x0283 // Ver.: always -#define ZCL_UNEXPECTED_PROGRAM_EXECUTION_ATTRIBUTE_ID 0x0284 // Ver.: always -#define ZCL_LIMIT_THRESHOLD_EXCEEDED_ATTRIBUTE_ID 0x0285 // Ver.: always -#define ZCL_LIMIT_THRESHOLD_OK_ATTRIBUTE_ID 0x0286 // Ver.: always -#define ZCL_LIMIT_THRESHOLD_CHANGED_ATTRIBUTE_ID 0x0287 // Ver.: always -#define ZCL_MAXIMUM_DEMAND_EXCEEDED_ATTRIBUTE_ID 0x0288 // Ver.: always -#define ZCL_PROFILE_CLEARED_ATTRIBUTE_ID 0x0289 // Ver.: always -#define ZCL_LOAD_PROFILE_CLEARED_ATTRIBUTE_ID 0x028A // Ver.: always -#define ZCL_BATTERY_WARN_ATTRIBUTE_ID 0x028B // Ver.: always -#define ZCL_WRONG_SIGNATURE_ATTRIBUTE_ID 0x028C // Ver.: always -#define ZCL_NO_SIGNATURE_ATTRIBUTE_ID 0x028D // Ver.: always -#define ZCL_SIGNATURE_NOT_VALID_ATTRIBUTE_ID 0x028E // Ver.: always -#define ZCL_UNAUTHORISE_ACTION_FROM_HAN_ATTRIBUTE_ID 0x028F // Ver.: always -#define ZCL_FAST_POLLING_START_ATTRIBUTE_ID 0x0290 // Ver.: always -#define ZCL_FAST_POLLING_END_ATTRIBUTE_ID 0x0291 // Ver.: always -#define ZCL_METER_REPORTING_INTERVAL_CHANGED_ATTRIBUTE_ID 0x0292 // Ver.: always -#define ZCL_DISCONNECT_TO_LOAD_LIMIT_ATTRIBUTE_ID 0x0293 // Ver.: always -#define ZCL_METER_SUPPLY_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0294 // Ver.: always -#define ZCL_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0295 // Ver.: always -#define ZCL_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0296 // Ver.: always -#define ZCL_DATA_ACCESS_VIA_LOCAL_PORT_ATTRIBUTE_ID 0x0297 // Ver.: always -#define ZCL_CONFIGURE_MIRROR_SUCCESS_ATTRIBUTE_ID 0x0298 // Ver.: always -#define ZCL_CONFIGURE_MIRROR_FAILURE_ATTRIBUTE_ID 0x0299 // Ver.: always -#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_SUCCESS_ATTRIBUTE_ID 0x029A // Ver.: always -#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_FAILURE_ATTRIBUTE_ID 0x029B // Ver.: always -#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_SUCCESS_ATTRIBUTE_ID 0x029C // Ver.: always -#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_FAILURE_ATTRIBUTE_ID 0x029D // Ver.: always -#define ZCL_STAY_AWAKE_REQUEST_HAN_ATTRIBUTE_ID 0x029E // Ver.: always -#define ZCL_STAY_AWAKE_REQUEST_WAN_ATTRIBUTE_ID 0x029F // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_A_ATTRIBUTE_ID 0x02B0 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_B_ATTRIBUTE_ID 0x02B1 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_C_ATTRIBUTE_ID 0x02B2 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_D_ATTRIBUTE_ID 0x02B3 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_E_ATTRIBUTE_ID 0x02B4 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_F_ATTRIBUTE_ID 0x02B5 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_G_ATTRIBUTE_ID 0x02B6 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_H_ATTRIBUTE_ID 0x02B7 // Ver.: always -#define ZCL_MANUFACTURER_SPECIFIC_I_ATTRIBUTE_ID 0x02B8 // Ver.: always -#define ZCL_GET_PROFILE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C0 // Ver.: always -#define ZCL_GET_PROFILE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C1 // Ver.: always -#define ZCL_GET_PROFILE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C2 // Ver.: always -#define ZCL_GET_PROFILE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C3 // Ver.: always -#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C4 // Ver.: always -#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C5 // Ver.: always -#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C6 // Ver.: always -#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C7 // Ver.: always -#define ZCL_MIRROR_REMOVED_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C8 // Ver.: always -#define ZCL_MIRROR_REMOVED_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C9 // Ver.: always -#define ZCL_MIRROR_REMOVED_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CA // Ver.: always -#define ZCL_MIRROR_REMOVED_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CB // Ver.: always -#define ZCL_GET_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02CC // Ver.: always -#define ZCL_GET_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02CD // Ver.: always -#define ZCL_GET_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CE // Ver.: always -#define ZCL_GET_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CF // Ver.: always -#define ZCL_TAKE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D0 // Ver.: always -#define ZCL_TAKE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D1 // Ver.: always -#define ZCL_TAKE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02D2 // Ver.: always -#define ZCL_TAKE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D3 // Ver.: always -#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D4 // Ver.: always -#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D5 // Ver.: always +#define ZCL_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_ID_CLIENT_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_TOU_TARIFF_ACTIVATION_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_BLOCK_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_BLOCK_TOU_TARIFF_ACTIVATED_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_SINGLE_TARIFF_RATE_ACTIVATED_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_ASYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_SYNCHRONOUS_BILLING_OCCURRED_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_TARIFF_NOT_SUPPORTED_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_PRICE_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_CURRENCY_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_CURRENCY_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_PRICE_MATRIX_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_PRICE_MATRIX_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_TARIFF_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_TARIFF_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_PUBLISH_PRICE_RECEIVED_ATTRIBUTE_ID 0x01B0 // Ver.: always +#define ZCL_PUBLISH_PRICE_ACTIONED_ATTRIBUTE_ID 0x01B1 // Ver.: always +#define ZCL_PUBLISH_PRICE_CANCELLED_ATTRIBUTE_ID 0x01B2 // Ver.: always +#define ZCL_PUBLISH_PRICE_REJECTED_ATTRIBUTE_ID 0x01B3 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_RECEIVED_ATTRIBUTE_ID 0x01B4 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_ACTIONED_ATTRIBUTE_ID 0x01B5 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_CANCELLED_ATTRIBUTE_ID 0x01B6 // Ver.: always +#define ZCL_PUBLISH_TARIFF_INFO_REJECTED_ATTRIBUTE_ID 0x01B7 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_RECEIVED_ATTRIBUTE_ID 0x01B8 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_ACTIONED_ATTRIBUTE_ID 0x01B9 // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_CANCELLED_ATTRIBUTE_ID 0x01BA // Ver.: always +#define ZCL_PUBLISH_PRICE_MATRIX_REJECTED_ATTRIBUTE_ID 0x01BB // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_RECEIVED_ATTRIBUTE_ID 0x01BC // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_ACTIONED_ATTRIBUTE_ID 0x01BD // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_CANCELLED_ATTRIBUTE_ID 0x01BE // Ver.: always +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_REJECTED_ATTRIBUTE_ID 0x01BF // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C0 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C1 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_CANCELLED_ATTRIBUTE_ID 0x01C2 // Ver.: always +#define ZCL_PUBLISH_CALORIFIC_VALUE_REJECTED_ATTRIBUTE_ID 0x01C3 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_RECEIVED_ATTRIBUTE_ID 0x01C4 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_ACTIONED_ATTRIBUTE_ID 0x01C5 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_CANCELLED_ATTRIBUTE_ID 0x01C6 // Ver.: always +#define ZCL_PUBLISH_CONVERSION_FACTOR_REJECTED_ATTRIBUTE_ID 0x01C7 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_RECEIVED_ATTRIBUTE_ID 0x01C8 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_ACTIONED_ATTRIBUTE_ID 0x01C9 // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_CANCELLED_ATTRIBUTE_ID 0x01CA // Ver.: always +#define ZCL_PUBLISH_CO2_VALUE_REJECTED_ATTRIBUTE_ID 0x01CB // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_RECEIVED_ATTRIBUTE_ID 0x01CC // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_ACTIONED_ATTRIBUTE_ID 0x01CD // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_CANCELLED_ATTRIBUTE_ID 0x01CE // Ver.: always +#define ZCL_PUBLISH_CPP_EVENT_REJECTED_ATTRIBUTE_ID 0x01CF // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_RECEIVED_ATTRIBUTE_ID 0x01D0 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_ACTIONED_ATTRIBUTE_ID 0x01D1 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_CANCELLED_ATTRIBUTE_ID 0x01D2 // Ver.: always +#define ZCL_PUBLISH_TIER_LABELS_REJECTED_ATTRIBUTE_ID 0x01D3 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01D4 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01D5 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01D6 // Ver.: always +#define ZCL_PUBLISH_BILLING_PERIOD_REJECTED_ATTRIBUTE_ID 0x01D7 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_RECEIVED_ATTRIBUTE_ID 0x01D8 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_ACTIONED_ATTRIBUTE_ID 0x01D9 // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_CANCELLED_ATTRIBUTE_ID 0x01DA // Ver.: always +#define ZCL_PUBLISH_CONSOLIDATED_BILL_REJECTED_ATTRIBUTE_ID 0x01DB // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_RECEIVED_ATTRIBUTE_ID 0x01DC // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_ACTIONED_ATTRIBUTE_ID 0x01DD // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_CANCELLED_ATTRIBUTE_ID 0x01DE // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_REJECTED_ATTRIBUTE_ID 0x01DF // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_RECEIVED_ATTRIBUTE_ID 0x01E0 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_ACTIONED_ATTRIBUTE_ID 0x01E1 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_CANCELLED_ATTRIBUTE_ID 0x01E2 // Ver.: always +#define ZCL_PUBLISH_CREDIT_PAYMENT_INFO_REJECTED_ATTRIBUTE_ID 0x01E3 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_RECEIVED_ATTRIBUTE_ID 0x01E4 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_ACTIONED_ATTRIBUTE_ID 0x01E5 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_CANCELLED_ATTRIBUTE_ID 0x01E6 // Ver.: always +#define ZCL_PUBLISH_CURRENCY_CONVERSION_REJECTED_ATTRIBUTE_ID 0x01E7 // Ver.: always +#define ZCL_CHECK_METER_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_LOW_BATTERY_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_TAMPER_DETECT_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_DEVICE_MANAGEMENT_SUPPLY_STATUS_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_SUPPLY_QUALITY_ATTRIBUTE_ID 0x0204 // Ver.: always +#define ZCL_LEAK_DETECT_ATTRIBUTE_ID 0x0205 // Ver.: always +#define ZCL_SERVICE_DISCONNECT_ATTRIBUTE_ID 0x0206 // Ver.: always +#define ZCL_REVERSE_FLOW_GENERAL_ATTRIBUTE_ID 0x0207 // Ver.: always +#define ZCL_METER_COVER_REMOVED_ATTRIBUTE_ID 0x0208 // Ver.: always +#define ZCL_METER_COVER_CLOSED_ATTRIBUTE_ID 0x0209 // Ver.: always +#define ZCL_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020A // Ver.: always +#define ZCL_NO_STRONG_MAGNETIC_FIELD_ATTRIBUTE_ID 0x020B // Ver.: always +#define ZCL_BATTERY_FAILURE_ATTRIBUTE_ID 0x020C // Ver.: always +#define ZCL_PROGRAM_MEMORY_ERROR_ATTRIBUTE_ID 0x020D // Ver.: always +#define ZCL_RAM_ERROR_ATTRIBUTE_ID 0x020E // Ver.: always +#define ZCL_NV_MEMORY_ERROR_ATTRIBUTE_ID 0x020F // Ver.: always +#define ZCL_LOW_VOLTAGE_L1_ATTRIBUTE_ID 0x0210 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L1_ATTRIBUTE_ID 0x0211 // Ver.: always +#define ZCL_LOW_VOLTAGE_L2_ATTRIBUTE_ID 0x0212 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L2_ATTRIBUTE_ID 0x0213 // Ver.: always +#define ZCL_LOW_VOLTAGE_L3_ATTRIBUTE_ID 0x0214 // Ver.: always +#define ZCL_HIGH_VOLTAGE_L3_ATTRIBUTE_ID 0x0215 // Ver.: always +#define ZCL_OVER_CURRENT_L1_ATTRIBUTE_ID 0x0216 // Ver.: always +#define ZCL_OVER_CURRENT_L2_ATTRIBUTE_ID 0x0217 // Ver.: always +#define ZCL_OVER_CURRENT_L3_ATTRIBUTE_ID 0x0218 // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L1_ATTRIBUTE_ID 0x0219 // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L1_ATTRIBUTE_ID 0x021A // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L2_ATTRIBUTE_ID 0x021B // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L2_ATTRIBUTE_ID 0x021C // Ver.: always +#define ZCL_FREQUENCY_TOO_LOW_L3_ATTRIBUTE_ID 0x021D // Ver.: always +#define ZCL_FREQUENCY_TOO_HIGH_L3_ATTRIBUTE_ID 0x021E // Ver.: always +#define ZCL_GROUND_FAULT_ATTRIBUTE_ID 0x021F // Ver.: always +#define ZCL_ELECTRIC_TAMPER_DETECT_ATTRIBUTE_ID 0x0220 // Ver.: always +#define ZCL_INCORRECT_POLARITY_ATTRIBUTE_ID 0x0221 // Ver.: always +#define ZCL_CURRENT_NO_VOLTAGE_ATTRIBUTE_ID 0x0222 // Ver.: always +#define ZCL_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0223 // Ver.: always +#define ZCL_OVER_VOLTAGE_ATTRIBUTE_ID 0x0224 // Ver.: always +#define ZCL_NORMAL_VOLTAGE_ATTRIBUTE_ID 0x0225 // Ver.: always +#define ZCL_PF_BELOW_THRESHOLD_ATTRIBUTE_ID 0x0226 // Ver.: always +#define ZCL_PF_ABOVE_THRESHOLD_ATTRIBUTE_ID 0x0227 // Ver.: always +#define ZCL_TERMINAL_COVER_REMOVED_ATTRIBUTE_ID 0x0228 // Ver.: always +#define ZCL_TERMINAL_COVER_CLOSED_ATTRIBUTE_ID 0x0229 // Ver.: always +#define ZCL_BURST_DETECT_ATTRIBUTE_ID 0x0230 // Ver.: always +#define ZCL_PRESSURE_TOO_LOW_ATTRIBUTE_ID 0x0231 // Ver.: always +#define ZCL_PRESSURE_TOO_HIGH_ATTRIBUTE_ID 0x0232 // Ver.: always +#define ZCL_FLOW_SENSOR_COMMUNICATION_ERROR_ATTRIBUTE_ID 0x0233 // Ver.: always +#define ZCL_FLOW_SENSOR_MEASUREMENT_FAULT_ATTRIBUTE_ID 0x0234 // Ver.: always +#define ZCL_FLOW_SENSOR_REVERSE_FLOW_ATTRIBUTE_ID 0x0235 // Ver.: always +#define ZCL_FLOW_SENSOR_AIR_DETECT_ATTRIBUTE_ID 0x0236 // Ver.: always +#define ZCL_PIPE_EMPTY_ATTRIBUTE_ID 0x0237 // Ver.: always +#define ZCL_INLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0250 // Ver.: always +#define ZCL_OUTLET_TEMP_SENSOR_FAULT_ATTRIBUTE_ID 0x0251 // Ver.: always +#define ZCL_REVERSE_FLOW_ATTRIBUTE_ID 0x0260 // Ver.: always +#define ZCL_TILT_TAMPER_ATTRIBUTE_ID 0x0261 // Ver.: always +#define ZCL_BATTERY_COVER_REMOVED_ATTRIBUTE_ID 0x0262 // Ver.: always +#define ZCL_BATTERY_COVER_CLOSED_ATTRIBUTE_ID 0x0263 // Ver.: always +#define ZCL_EXCESS_FLOW_ATTRIBUTE_ID 0x0264 // Ver.: always +#define ZCL_TILT_TAMPER_ENABLED_ATTRIBUTE_ID 0x0265 // Ver.: always +#define ZCL_MEASUREMENT_SYSTEM_ERROR_ATTRIBUTE_ID 0x0270 // Ver.: always +#define ZCL_WATCHDOG_ERROR_ATTRIBUTE_ID 0x0271 // Ver.: always +#define ZCL_SUPPLY_DISCONNECT_FAILURE_ATTRIBUTE_ID 0x0272 // Ver.: always +#define ZCL_SUPPLY_CONNECT_FAILURE_ATTRIBUTE_ID 0x0273 // Ver.: always +#define ZCL_MEASUREMENT_SOFTWARE_CHANGED_ATTRIBUTE_ID 0x0274 // Ver.: always +#define ZCL_DST_ENABLED_ATTRIBUTE_ID 0x0275 // Ver.: always +#define ZCL_DST_DISABLED_ATTRIBUTE_ID 0x0276 // Ver.: always +#define ZCL_CLOCK_ADJ_BACKWARD_ATTRIBUTE_ID 0x0277 // Ver.: always +#define ZCL_CLOCK_ADJ_FORWARD_ATTRIBUTE_ID 0x0278 // Ver.: always +#define ZCL_CLOCK_INVALID_ATTRIBUTE_ID 0x0279 // Ver.: always +#define ZCL_COMMUNICATION_ERROR_HAN_ATTRIBUTE_ID 0x027A // Ver.: always +#define ZCL_COMMUNICATION_OK_HAN_ATTRIBUTE_ID 0x027B // Ver.: always +#define ZCL_METER_FRAUD_ATTEMPT_ATTRIBUTE_ID 0x027C // Ver.: always +#define ZCL_POWER_LOSS_ATTRIBUTE_ID 0x027D // Ver.: always +#define ZCL_UNUSUAL_HAN_TRAFFIC_ATTRIBUTE_ID 0x027E // Ver.: always +#define ZCL_UNEXPECTED_CLOCK_CHANGE_ATTRIBUTE_ID 0x027F // Ver.: always +#define ZCL_COMMS_USING_UNAUTHENTICATED_COMPONENT_ATTRIBUTE_ID 0x0280 // Ver.: always +#define ZCL_METERING_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0281 // Ver.: always +#define ZCL_METERING_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0282 // Ver.: always +#define ZCL_UNEXPECTED_HW_RESET_ATTRIBUTE_ID 0x0283 // Ver.: always +#define ZCL_UNEXPECTED_PROGRAM_EXECUTION_ATTRIBUTE_ID 0x0284 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_EXCEEDED_ATTRIBUTE_ID 0x0285 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_OK_ATTRIBUTE_ID 0x0286 // Ver.: always +#define ZCL_LIMIT_THRESHOLD_CHANGED_ATTRIBUTE_ID 0x0287 // Ver.: always +#define ZCL_MAXIMUM_DEMAND_EXCEEDED_ATTRIBUTE_ID 0x0288 // Ver.: always +#define ZCL_PROFILE_CLEARED_ATTRIBUTE_ID 0x0289 // Ver.: always +#define ZCL_LOAD_PROFILE_CLEARED_ATTRIBUTE_ID 0x028A // Ver.: always +#define ZCL_BATTERY_WARN_ATTRIBUTE_ID 0x028B // Ver.: always +#define ZCL_WRONG_SIGNATURE_ATTRIBUTE_ID 0x028C // Ver.: always +#define ZCL_NO_SIGNATURE_ATTRIBUTE_ID 0x028D // Ver.: always +#define ZCL_SIGNATURE_NOT_VALID_ATTRIBUTE_ID 0x028E // Ver.: always +#define ZCL_UNAUTHORISE_ACTION_FROM_HAN_ATTRIBUTE_ID 0x028F // Ver.: always +#define ZCL_FAST_POLLING_START_ATTRIBUTE_ID 0x0290 // Ver.: always +#define ZCL_FAST_POLLING_END_ATTRIBUTE_ID 0x0291 // Ver.: always +#define ZCL_METER_REPORTING_INTERVAL_CHANGED_ATTRIBUTE_ID 0x0292 // Ver.: always +#define ZCL_DISCONNECT_TO_LOAD_LIMIT_ATTRIBUTE_ID 0x0293 // Ver.: always +#define ZCL_METER_SUPPLY_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0294 // Ver.: always +#define ZCL_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0295 // Ver.: always +#define ZCL_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED_ATTRIBUTE_ID 0x0296 // Ver.: always +#define ZCL_DATA_ACCESS_VIA_LOCAL_PORT_ATTRIBUTE_ID 0x0297 // Ver.: always +#define ZCL_CONFIGURE_MIRROR_SUCCESS_ATTRIBUTE_ID 0x0298 // Ver.: always +#define ZCL_CONFIGURE_MIRROR_FAILURE_ATTRIBUTE_ID 0x0299 // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_SUCCESS_ATTRIBUTE_ID 0x029A // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAG_SCHEME_FAILURE_ATTRIBUTE_ID 0x029B // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_SUCCESS_ATTRIBUTE_ID 0x029C // Ver.: always +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_FAILURE_ATTRIBUTE_ID 0x029D // Ver.: always +#define ZCL_STAY_AWAKE_REQUEST_HAN_ATTRIBUTE_ID 0x029E // Ver.: always +#define ZCL_STAY_AWAKE_REQUEST_WAN_ATTRIBUTE_ID 0x029F // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_A_ATTRIBUTE_ID 0x02B0 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_B_ATTRIBUTE_ID 0x02B1 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_C_ATTRIBUTE_ID 0x02B2 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_D_ATTRIBUTE_ID 0x02B3 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_E_ATTRIBUTE_ID 0x02B4 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_F_ATTRIBUTE_ID 0x02B5 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_G_ATTRIBUTE_ID 0x02B6 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_H_ATTRIBUTE_ID 0x02B7 // Ver.: always +#define ZCL_MANUFACTURER_SPECIFIC_I_ATTRIBUTE_ID 0x02B8 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C0 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C1 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C2 // Ver.: always +#define ZCL_GET_PROFILE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C3 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C4 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C5 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02C6 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02C7 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02C8 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02C9 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CA // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CB // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02CC // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02CD // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02CE // Ver.: always +#define ZCL_GET_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02CF // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D0 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D1 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02D2 // Ver.: always +#define ZCL_TAKE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D3 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D4 // Ver.: always +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D5 // Ver.: always #define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02D6 // Ver.: always -#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D7 // Ver.: always -#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D8 // Ver.: always -#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D9 // Ver.: always -#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DA // Ver.: always -#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DB // Ver.: always -#define ZCL_START_SAMPLING_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02DC // Ver.: always -#define ZCL_START_SAMPLING_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02DD // Ver.: always -#define ZCL_START_SAMPLING_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DE // Ver.: always -#define ZCL_START_SAMPLING_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DF // Ver.: always -#define ZCL_GET_SAMPLED_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02E0 // Ver.: always -#define ZCL_GET_SAMPLED_DATA_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02E1 // Ver.: always -#define ZCL_GET_SAMPLED_DATA_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02E2 // Ver.: always -#define ZCL_GET_SAMPLED_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x02E3 // Ver.: always -#define ZCL_SUPPLY_ON_ATTRIBUTE_ID 0x02E4 // Ver.: always -#define ZCL_SUPPLY_ARMED_ATTRIBUTE_ID 0x02E5 // Ver.: always -#define ZCL_SUPPLY_OFF_ATTRIBUTE_ID 0x02E6 // Ver.: always -#define ZCL_DISCONNECTED_DUE_TO_TAMPER_DETECTED_ATTRIBUTE_ID 0x02E7 // Ver.: always -#define ZCL_MANUAL_DISCONNECT_ATTRIBUTE_ID 0x02E8 // Ver.: always -#define ZCL_MANUAL_CONNECT_ATTRIBUTE_ID 0x02E9 // Ver.: always -#define ZCL_REMOTE_DISCONNECTION_ATTRIBUTE_ID 0x02EA // Ver.: always -#define ZCL_REMOTE_CONNECT_ATTRIBUTE_ID 0x02EB // Ver.: always -#define ZCL_LOCAL_DISCONNECTION_ATTRIBUTE_ID 0x02EC // Ver.: always -#define ZCL_LOCAL_CONNECT_ATTRIBUTE_ID 0x02ED // Ver.: always -#define ZCL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02EE // Ver.: always -#define ZCL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02EF // Ver.: always -#define ZCL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F0 // Ver.: always -#define ZCL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F1 // Ver.: always -#define ZCL_LOCAL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02F2 // Ver.: always -#define ZCL_LOCAL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02F3 // Ver.: always -#define ZCL_LOCAL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F4 // Ver.: always -#define ZCL_LOCAL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F5 // Ver.: always -#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_RECEIVED_ATTRIBUTE_ID 0x02F6 // Ver.: always -#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_ACTIONED_ATTRIBUTE_ID 0x02F7 // Ver.: always -#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_CANCELLED_ATTRIBUTE_ID 0x02F8 // Ver.: always -#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_REJECTED_ATTRIBUTE_ID 0x02F9 // Ver.: always -#define ZCL_MESSAGE_CONFIRMATION_SENT_ATTRIBUTE_ID 0x0300 // Ver.: always -#define ZCL_DISPLAY_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C0 // Ver.: always -#define ZCL_DISPLAY_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C1 // Ver.: always -#define ZCL_DISPLAY_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C2 // Ver.: always -#define ZCL_DISPLAY_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C3 // Ver.: always -#define ZCL_CANCEL_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C4 // Ver.: always -#define ZCL_CANCEL_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C5 // Ver.: always -#define ZCL_CANCEL_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C6 // Ver.: always -#define ZCL_CANCEL_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C7 // Ver.: always -#define ZCL_LOW_CREDIT_ATTRIBUTE_ID 0x0400 // Ver.: always -#define ZCL_NO_CREDIT_ATTRIBUTE_ID 0x0401 // Ver.: always -#define ZCL_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0402 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_ENABLED_ATTRIBUTE_ID 0x0403 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0404 // Ver.: always -#define ZCL_PREPAY_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0405 // Ver.: always -#define ZCL_PHYSICAL_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0420 // Ver.: always -#define ZCL_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0421 // Ver.: always -#define ZCL_DISCOUNT_APPLIED_ATTRIBUTE_ID 0x0422 // Ver.: always -#define ZCL_CREDIT_ADJUSTMENT_ATTRIBUTE_ID 0x0423 // Ver.: always -#define ZCL_CREDIT_ADJUST_FAIL_ATTRIBUTE_ID 0x0424 // Ver.: always -#define ZCL_DEBT_ADJUSTMENT_ATTRIBUTE_ID 0x0425 // Ver.: always -#define ZCL_DEBT_ADJUST_FAIL_ATTRIBUTE_ID 0x0426 // Ver.: always -#define ZCL_MODE_CHANGE_ATTRIBUTE_ID 0x0427 // Ver.: always -#define ZCL_TOPUP_CODE_ERROR_ATTRIBUTE_ID 0x0428 // Ver.: always -#define ZCL_TOPUP_ALREADY_USED_ATTRIBUTE_ID 0x0429 // Ver.: always -#define ZCL_TOPUP_CODE_INVALID_ATTRIBUTE_ID 0x042A // Ver.: always -#define ZCL_TOPUP_ACCEPTED_VIA_REMOTE_ATTRIBUTE_ID 0x042B // Ver.: always -#define ZCL_TOPUP_ACCEPTED_VIA_MANUAL_ENTRY_ATTRIBUTE_ID 0x042C // Ver.: always -#define ZCL_FRIENDLY_CREDIT_IN_USE_ATTRIBUTE_ID 0x042D // Ver.: always -#define ZCL_FRIENDLY_CREDIT_END_WARNING_ATTRIBUTE_ID 0x042E // Ver.: always -#define ZCL_FRIENDLY_CREDIT_PERIOD_END_ATTRIBUTE_ID 0x042F // Ver.: always -#define ZCL_PREPAY_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0430 // Ver.: always -#define ZCL_PREPAY_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0431 // Ver.: always -#define ZCL_PREPAY_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0432 // Ver.: always -#define ZCL_TOPUP_VALUE_TOO_LARGE_ATTRIBUTE_ID 0x0433 // Ver.: always -#define ZCL_MODE_CREDIT_2_PREPAY_ATTRIBUTE_ID 0x0441 // Ver.: always -#define ZCL_MODE_PREPAY_2_CREDIT_ATTRIBUTE_ID 0x0442 // Ver.: always -#define ZCL_MODE_DEFAULT_ATTRIBUTE_ID 0x0443 // Ver.: always -#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_RECEIVED_ATTRIBUTE_ID 0x04C0 // Ver.: always -#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_ACTIONED_ATTRIBUTE_ID 0x04C1 // Ver.: always -#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_CANCELLED_ATTRIBUTE_ID 0x04C2 // Ver.: always -#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_REJECTED_ATTRIBUTE_ID 0x04C3 // Ver.: always -#define ZCL_CHANGE_DEBT_RECEIVED_ATTRIBUTE_ID 0x04C4 // Ver.: always -#define ZCL_CHANGE_DEBT_ACTIONED_ATTRIBUTE_ID 0x04C5 // Ver.: always -#define ZCL_CHANGE_DEBT_CANCELLED_ATTRIBUTE_ID 0x04C6 // Ver.: always -#define ZCL_CHANGE_DEBT_REJECTED_ATTRIBUTE_ID 0x04C7 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_SETUP_RECEIVED_ATTRIBUTE_ID 0x04C8 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_SETUP_ACTIONED_ATTRIBUTE_ID 0x04C9 // Ver.: always -#define ZCL_EMERGENCY_CREDIT_SETUP_CANCELLED_ATTRIBUTE_ID 0x04CA // Ver.: always -#define ZCL_EMERGENCY_CREDIT_SETUP_REJECTED_ATTRIBUTE_ID 0x04CB // Ver.: always -#define ZCL_CONSUMER_TOPUP_RECEIVED_ATTRIBUTE_ID 0x04CC // Ver.: always -#define ZCL_CONSUMER_TOPUP_ACTIONED_ATTRIBUTE_ID 0x04CD // Ver.: always -#define ZCL_CONSUMER_TOPUP_CANCELLED_ATTRIBUTE_ID 0x04CE // Ver.: always -#define ZCL_CONSUMER_TOPUP_REJECTED_ATTRIBUTE_ID 0x04CF // Ver.: always -#define ZCL_CREDIT_ADJUSTMENT_RECEIVED_ATTRIBUTE_ID 0x04D0 // Ver.: always -#define ZCL_CREDIT_ADJUSTMENT_ACTIONED_ATTRIBUTE_ID 0x04D1 // Ver.: always -#define ZCL_CREDIT_ADJUSTMENT_CANCELLED_ATTRIBUTE_ID 0x04D2 // Ver.: always -#define ZCL_CREDIT_ADJUSTMENT_REJECTED_ATTRIBUTE_ID 0x04D3 // Ver.: always -#define ZCL_CHANGE_PAYMENT_MODE_RECEIVED_ATTRIBUTE_ID 0x04D4 // Ver.: always -#define ZCL_CHANGE_PAYMENT_MODE_ACTIONED_ATTRIBUTE_ID 0x04D5 // Ver.: always -#define ZCL_CHANGE_PAYMENT_MODE_CANCELLED_ATTRIBUTE_ID 0x04D6 // Ver.: always -#define ZCL_CHANGE_PAYMENT_MODE_REJECTED_ATTRIBUTE_ID 0x04D7 // Ver.: always -#define ZCL_GET_PREPAY_SNAPSHOT_RECEIVED_ATTRIBUTE_ID 0x04D8 // Ver.: always -#define ZCL_GET_PREPAY_SNAPSHOT_ACTIONED_ATTRIBUTE_ID 0x04D9 // Ver.: always -#define ZCL_GET_PREPAY_SNAPSHOT_CANCELLED_ATTRIBUTE_ID 0x04DA // Ver.: always -#define ZCL_GET_PREPAY_SNAPSHOT_REJECTED_ATTRIBUTE_ID 0x04DB // Ver.: always -#define ZCL_GET_TOPUP_LOG_RECEIVED_ATTRIBUTE_ID 0x04DC // Ver.: always -#define ZCL_GET_TOPUP_LOG_ACTIONED_ATTRIBUTE_ID 0x04DD // Ver.: always -#define ZCL_GET_TOPUP_LOG_CANCELLED_ATTRIBUTE_ID 0x04DE // Ver.: always -#define ZCL_GET_TOPUP_LOG_REJECTED_ATTRIBUTE_ID 0x04DF // Ver.: always -#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_RECEIVED_ATTRIBUTE_ID 0x04E0 // Ver.: always -#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_ACTIONED_ATTRIBUTE_ID 0x04E1 // Ver.: always -#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_CANCELLED_ATTRIBUTE_ID 0x04E2 // Ver.: always -#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_REJECTED_ATTRIBUTE_ID 0x04E3 // Ver.: always -#define ZCL_GET_DEBT_REPAY_LOG_RECEIVED_ATTRIBUTE_ID 0x04E4 // Ver.: always -#define ZCL_GET_DEBT_REPAY_LOG_ACTIONED_ATTRIBUTE_ID 0x04E5 // Ver.: always -#define ZCL_GET_DEBT_REPAY_LOG_CANCELLED_ATTRIBUTE_ID 0x04E6 // Ver.: always -#define ZCL_GET_DEBT_REPAY_LOG_REJECTED_ATTRIBUTE_ID 0x04E7 // Ver.: always -#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_RECEIVED_ATTRIBUTE_ID 0x04E8 // Ver.: always -#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_ACTIONED_ATTRIBUTE_ID 0x04E9 // Ver.: always -#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_CANCELLED_ATTRIBUTE_ID 0x04EA // Ver.: always -#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_REJECTED_ATTRIBUTE_ID 0x04EB // Ver.: always -#define ZCL_SET_OVERALL_DEBT_CAP_RECEIVED_ATTRIBUTE_ID 0x04EC // Ver.: always -#define ZCL_SET_OVERALL_DEBT_CAP_ACTIONED_ATTRIBUTE_ID 0x04ED // Ver.: always -#define ZCL_SET_OVERALL_DEBT_CAP_CANCELLED_ATTRIBUTE_ID 0x04EE // Ver.: always -#define ZCL_SET_OVERALL_DEBT_CAP_REJECTED_ATTRIBUTE_ID 0x04EF // Ver.: always -#define ZCL_CALENDAR_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0500 // Ver.: always -#define ZCL_CALENDAR_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0501 // Ver.: always -#define ZCL_CALENDAR_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0502 // Ver.: always -#define ZCL_PUBLISH_CALENDAR_RECEIVED_ATTRIBUTE_ID 0x05C0 // Ver.: always -#define ZCL_PUBLISH_CALENDAR_ACTIONED_ATTRIBUTE_ID 0x05C1 // Ver.: always -#define ZCL_PUBLISH_CALENDAR_CANCELLED_ATTRIBUTE_ID 0x05C2 // Ver.: always -#define ZCL_PUBLISH_CALENDAR_REJECTED_ATTRIBUTE_ID 0x05C3 // Ver.: always -#define ZCL_PUBLISH_DAY_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C4 // Ver.: always -#define ZCL_PUBLISH_DAY_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C5 // Ver.: always -#define ZCL_PUBLISH_DAY_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05C6 // Ver.: always -#define ZCL_PUBLISH_DAY_PROFILE_REJECTED_ATTRIBUTE_ID 0x05C7 // Ver.: always -#define ZCL_PUBLISH_WEEK_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C8 // Ver.: always -#define ZCL_PUBLISH_WEEK_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C9 // Ver.: always -#define ZCL_PUBLISH_WEEK_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05CA // Ver.: always -#define ZCL_PUBLISH_WEEK_PROFILE_REJECTED_ATTRIBUTE_ID 0x05CB // Ver.: always -#define ZCL_PUBLISH_SEASONS_RECEIVED_ATTRIBUTE_ID 0x05CC // Ver.: always -#define ZCL_PUBLISH_SEASONS_ACTIONED_ATTRIBUTE_ID 0x05CD // Ver.: always -#define ZCL_PUBLISH_SEASONS_CANCELLED_ATTRIBUTE_ID 0x05CE // Ver.: always -#define ZCL_PUBLISH_SEASONS_REJECTED_ATTRIBUTE_ID 0x05CF // Ver.: always -#define ZCL_PUBLISH_SPECIAL_DAYS_RECEIVED_ATTRIBUTE_ID 0x05D0 // Ver.: always -#define ZCL_PUBLISH_SPECIAL_DAYS_ACTIONED_ATTRIBUTE_ID 0x05D1 // Ver.: always -#define ZCL_PUBLISH_SPECIAL_DAYS_CANCELLED_ATTRIBUTE_ID 0x05D2 // Ver.: always -#define ZCL_PUBLISH_SPECIAL_DAYS_REJECTED_ATTRIBUTE_ID 0x05D3 // Ver.: always -#define ZCL_PASSWORD_1_CHANGE_ATTRIBUTE_ID 0x0600 // Ver.: always -#define ZCL_PASSWORD_2_CHANGE_ATTRIBUTE_ID 0x0601 // Ver.: always -#define ZCL_PASSWORD_3_CHANGE_ATTRIBUTE_ID 0x0602 // Ver.: always -#define ZCL_PASSWORD_4_CHANGE_ATTRIBUTE_ID 0x0603 // Ver.: always -#define ZCL_EVENT_LOG_CLEARED_ATTRIBUTE_ID 0x0604 // Ver.: always -#define ZCL_ZIGBEE_APS_TIMEOUT_ATTRIBUTE_ID 0x0610 // Ver.: always -#define ZCL_ZIGBEE_IEEE_TRANSMISSION_FAILURE_OVER_THRESHOLD_ATTRIBUTE_ID 0x0611 // Ver.: always -#define ZCL_ZIGBEE_IEEE_FRAME_CHECK_SEQUENCE_THRESHOLD_ATTRIBUTE_ID 0x0612 // Ver.: always -#define ZCL_ERROR_CERTIFICATE_ATTRIBUTE_ID 0x0613 // Ver.: always -#define ZCL_ERROR_SIGNATURE_ATTRIBUTE_ID 0x0614 // Ver.: always -#define ZCL_ERROR_PROGRAM_STORAGE_ATTRIBUTE_ID 0x0615 // Ver.: always -#define ZCL_PUBLISH_COT_RECEIVED_ATTRIBUTE_ID 0x06C0 // Ver.: always -#define ZCL_PUBLISH_COT_ACTIONED_ATTRIBUTE_ID 0x06C1 // Ver.: always -#define ZCL_PUBLISH_COT_CANCELLED_ATTRIBUTE_ID 0x06C2 // Ver.: always -#define ZCL_PUBLISH_COT_REJECTED_ATTRIBUTE_ID 0x06C3 // Ver.: always -#define ZCL_PUBLISH_COS_RECEIVED_ATTRIBUTE_ID 0x06C4 // Ver.: always -#define ZCL_PUBLISH_COS_ACTIONED_ATTRIBUTE_ID 0x06C5 // Ver.: always -#define ZCL_PUBLISH_COS_CANCELLED_ATTRIBUTE_ID 0x06C6 // Ver.: always -#define ZCL_PUBLISH_COS_REJECTED_ATTRIBUTE_ID 0x06C7 // Ver.: always -#define ZCL_CHANGE_PASSWORD_RECEIVED_ATTRIBUTE_ID 0x06C8 // Ver.: always -#define ZCL_CHANGE_PASSWORD_ACTIONED_ATTRIBUTE_ID 0x06C9 // Ver.: always -#define ZCL_CHANGE_PASSWORD_CANCELLED_ATTRIBUTE_ID 0x06CA // Ver.: always -#define ZCL_CHANGE_PASSWORD_REJECTED_ATTRIBUTE_ID 0x06CB // Ver.: always -#define ZCL_SET_EVENT_CONFIGURATION_RECEIVED_ATTRIBUTE_ID 0x06CC // Ver.: always -#define ZCL_SET_EVENT_CONFIGURATION_ACTIONED_ATTRIBUTE_ID 0x06CD // Ver.: always -#define ZCL_SET_EVENT_CONFIGURATION_CANCELLED_ATTRIBUTE_ID 0x06CE // Ver.: always -#define ZCL_SET_EVENT_CONFIGURATION_REJECTED_ATTRIBUTE_ID 0x06CF // Ver.: always -#define ZCL_UPDATE_SITE_ID_RECEIVED_ATTRIBUTE_ID 0x06D0 // Ver.: always -#define ZCL_UPDATE_SITE_ID_ACTIONED_ATTRIBUTE_ID 0x06D1 // Ver.: always -#define ZCL_UPDATE_SITE_ID_CANCELLED_ATTRIBUTE_ID 0x06D2 // Ver.: always -#define ZCL_UPDATE_SITE_ID_REJECTED_ATTRIBUTE_ID 0x06D3 // Ver.: always -#define ZCL_UPDATE_CIN_RECEIVED_ATTRIBUTE_ID 0x06D4 // Ver.: always -#define ZCL_UPDATE_CIN_ACTIONED_ATTRIBUTE_ID 0x06D5 // Ver.: always -#define ZCL_UPDATE_CIN_CANCELLED_ATTRIBUTE_ID 0x06D6 // Ver.: always -#define ZCL_UPDATE_CIN_REJECTED_ATTRIBUTE_ID 0x06D7 // Ver.: always -#define ZCL_TUNNELING_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0700 // Ver.: always -#define ZCL_UNSUPPORTED_PROTOCOL_ATTRIBUTE_ID 0x0701 // Ver.: always -#define ZCL_INCORRECT_PROTOCOL_ATTRIBUTE_ID 0x0702 // Ver.: always -#define ZCL_REQUEST_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C0 // Ver.: always -#define ZCL_REQUEST_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C1 // Ver.: always -#define ZCL_REQUEST_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C2 // Ver.: always -#define ZCL_CLOSE_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C3 // Ver.: always -#define ZCL_CLOSE_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C4 // Ver.: always -#define ZCL_CLOSE_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C5 // Ver.: always -#define ZCL_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C6 // Ver.: always -#define ZCL_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C7 // Ver.: always -#define ZCL_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C8 // Ver.: always -#define ZCL_TRANSFER_DATA_ERROR_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C9 // Ver.: always -#define ZCL_TRANSFER_DATA_ERROR_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CA // Ver.: always -#define ZCL_TRANSFER_DATA_ERROR_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CB // Ver.: always -#define ZCL_ACK_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CC // Ver.: always -#define ZCL_ACK_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CD // Ver.: always -#define ZCL_ACK_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CE // Ver.: always -#define ZCL_READY_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CF // Ver.: always -#define ZCL_READY_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D0 // Ver.: always -#define ZCL_READY_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D1 // Ver.: always -#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07D2 // Ver.: always -#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D3 // Ver.: always -#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D4 // Ver.: always -#define ZCL_FIRMWARE_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0800 // Ver.: always -#define ZCL_FIRMWARE_ACTIVATED_ATTRIBUTE_ID 0x0801 // Ver.: always -#define ZCL_FIRMWARE_ACTIVATION_FAILURE_ATTRIBUTE_ID 0x0802 // Ver.: always -#define ZCL_PATCH_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0803 // Ver.: always -#define ZCL_PATCH_ACTIVATED_ATTRIBUTE_ID 0x0804 // Ver.: always -#define ZCL_PATCH_FAILURE_ATTRIBUTE_ID 0x0805 // Ver.: always -#define ZCL_IMAGE_NOTIFY_COMMAND_RECEIVED_ATTRIBUTE_ID 0x08C0 // Ver.: always -#define ZCL_IMAGE_NOTIFY_COMMAND_REJECTED_ATTRIBUTE_ID 0x08C1 // Ver.: always -#define ZCL_QUERY_NEXT_IMAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C2 // Ver.: always -#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C3 // Ver.: always -#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C4 // Ver.: always -#define ZCL_IMAGE_BLOCK_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C5 // Ver.: always -#define ZCL_IMAGE_PAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C6 // Ver.: always -#define ZCL_IMAGE_BLOCK_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C7 // Ver.: always -#define ZCL_IMAGE_BLOCK_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C8 // Ver.: always -#define ZCL_UPGRADE_END_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C9 // Ver.: always -#define ZCL_UPGRADE_END_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CA // Ver.: always -#define ZCL_UPGRADE_END_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CB // Ver.: always -#define ZCL_QUERY_SPECIFIC_FILE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08CC // Ver.: always -#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CD // Ver.: always -#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CE // Ver.: always -#define ZCL_DEVICE_MANAGEMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_DEVICE_MANAGEMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_REJECTED_ATTRIBUTE_ID 0x02D7 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02D8 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02D9 // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DA // Ver.: always +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DB // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02DC // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02DD // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02DE // Ver.: always +#define ZCL_START_SAMPLING_COMMAND_REJECTED_ATTRIBUTE_ID 0x02DF // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x02E0 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_ACTIONED_ATTRIBUTE_ID 0x02E1 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_CANCELLED_ATTRIBUTE_ID 0x02E2 // Ver.: always +#define ZCL_GET_SAMPLED_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x02E3 // Ver.: always +#define ZCL_SUPPLY_ON_ATTRIBUTE_ID 0x02E4 // Ver.: always +#define ZCL_SUPPLY_ARMED_ATTRIBUTE_ID 0x02E5 // Ver.: always +#define ZCL_SUPPLY_OFF_ATTRIBUTE_ID 0x02E6 // Ver.: always +#define ZCL_DISCONNECTED_DUE_TO_TAMPER_DETECTED_ATTRIBUTE_ID 0x02E7 // Ver.: always +#define ZCL_MANUAL_DISCONNECT_ATTRIBUTE_ID 0x02E8 // Ver.: always +#define ZCL_MANUAL_CONNECT_ATTRIBUTE_ID 0x02E9 // Ver.: always +#define ZCL_REMOTE_DISCONNECTION_ATTRIBUTE_ID 0x02EA // Ver.: always +#define ZCL_REMOTE_CONNECT_ATTRIBUTE_ID 0x02EB // Ver.: always +#define ZCL_LOCAL_DISCONNECTION_ATTRIBUTE_ID 0x02EC // Ver.: always +#define ZCL_LOCAL_CONNECT_ATTRIBUTE_ID 0x02ED // Ver.: always +#define ZCL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02EE // Ver.: always +#define ZCL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02EF // Ver.: always +#define ZCL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F0 // Ver.: always +#define ZCL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F1 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_RECEIVED_ATTRIBUTE_ID 0x02F2 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_ACTIONED_ATTRIBUTE_ID 0x02F3 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_CANCELLED_ATTRIBUTE_ID 0x02F4 // Ver.: always +#define ZCL_LOCAL_CHANGE_SUPPLY_REJECTED_ATTRIBUTE_ID 0x02F5 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_RECEIVED_ATTRIBUTE_ID 0x02F6 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_ACTIONED_ATTRIBUTE_ID 0x02F7 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_CANCELLED_ATTRIBUTE_ID 0x02F8 // Ver.: always +#define ZCL_PUBLISH_UNCONTROLLED_FLOW_THRESHOLD_REJECTED_ATTRIBUTE_ID 0x02F9 // Ver.: always +#define ZCL_MESSAGE_CONFIRMATION_SENT_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C0 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C1 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C2 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C3 // Ver.: always +#define ZCL_CANCEL_MESSAGE_RECEIVED_ATTRIBUTE_ID 0x03C4 // Ver.: always +#define ZCL_CANCEL_MESSAGE_ACTIONED_ATTRIBUTE_ID 0x03C5 // Ver.: always +#define ZCL_CANCEL_MESSAGE_CANCELLED_ATTRIBUTE_ID 0x03C6 // Ver.: always +#define ZCL_CANCEL_MESSAGE_REJECTED_ATTRIBUTE_ID 0x03C7 // Ver.: always +#define ZCL_LOW_CREDIT_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_NO_CREDIT_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_ENABLED_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_EXHAUSTED_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_PREPAY_IHD_LOW_CREDIT_WARNING_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_PHYSICAL_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0420 // Ver.: always +#define ZCL_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER_ATTRIBUTE_ID 0x0421 // Ver.: always +#define ZCL_DISCOUNT_APPLIED_ATTRIBUTE_ID 0x0422 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_ATTRIBUTE_ID 0x0423 // Ver.: always +#define ZCL_CREDIT_ADJUST_FAIL_ATTRIBUTE_ID 0x0424 // Ver.: always +#define ZCL_DEBT_ADJUSTMENT_ATTRIBUTE_ID 0x0425 // Ver.: always +#define ZCL_DEBT_ADJUST_FAIL_ATTRIBUTE_ID 0x0426 // Ver.: always +#define ZCL_MODE_CHANGE_ATTRIBUTE_ID 0x0427 // Ver.: always +#define ZCL_TOPUP_CODE_ERROR_ATTRIBUTE_ID 0x0428 // Ver.: always +#define ZCL_TOPUP_ALREADY_USED_ATTRIBUTE_ID 0x0429 // Ver.: always +#define ZCL_TOPUP_CODE_INVALID_ATTRIBUTE_ID 0x042A // Ver.: always +#define ZCL_TOPUP_ACCEPTED_VIA_REMOTE_ATTRIBUTE_ID 0x042B // Ver.: always +#define ZCL_TOPUP_ACCEPTED_VIA_MANUAL_ENTRY_ATTRIBUTE_ID 0x042C // Ver.: always +#define ZCL_FRIENDLY_CREDIT_IN_USE_ATTRIBUTE_ID 0x042D // Ver.: always +#define ZCL_FRIENDLY_CREDIT_END_WARNING_ATTRIBUTE_ID 0x042E // Ver.: always +#define ZCL_FRIENDLY_CREDIT_PERIOD_END_ATTRIBUTE_ID 0x042F // Ver.: always +#define ZCL_PREPAY_ERROR_REG_CLEAR_ATTRIBUTE_ID 0x0430 // Ver.: always +#define ZCL_PREPAY_ALARM_REG_CLEAR_ATTRIBUTE_ID 0x0431 // Ver.: always +#define ZCL_PREPAY_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0432 // Ver.: always +#define ZCL_TOPUP_VALUE_TOO_LARGE_ATTRIBUTE_ID 0x0433 // Ver.: always +#define ZCL_MODE_CREDIT_2_PREPAY_ATTRIBUTE_ID 0x0441 // Ver.: always +#define ZCL_MODE_PREPAY_2_CREDIT_ATTRIBUTE_ID 0x0442 // Ver.: always +#define ZCL_MODE_DEFAULT_ATTRIBUTE_ID 0x0443 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_RECEIVED_ATTRIBUTE_ID 0x04C0 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_ACTIONED_ATTRIBUTE_ID 0x04C1 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_CANCELLED_ATTRIBUTE_ID 0x04C2 // Ver.: always +#define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_REJECTED_ATTRIBUTE_ID 0x04C3 // Ver.: always +#define ZCL_CHANGE_DEBT_RECEIVED_ATTRIBUTE_ID 0x04C4 // Ver.: always +#define ZCL_CHANGE_DEBT_ACTIONED_ATTRIBUTE_ID 0x04C5 // Ver.: always +#define ZCL_CHANGE_DEBT_CANCELLED_ATTRIBUTE_ID 0x04C6 // Ver.: always +#define ZCL_CHANGE_DEBT_REJECTED_ATTRIBUTE_ID 0x04C7 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_RECEIVED_ATTRIBUTE_ID 0x04C8 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_ACTIONED_ATTRIBUTE_ID 0x04C9 // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_CANCELLED_ATTRIBUTE_ID 0x04CA // Ver.: always +#define ZCL_EMERGENCY_CREDIT_SETUP_REJECTED_ATTRIBUTE_ID 0x04CB // Ver.: always +#define ZCL_CONSUMER_TOPUP_RECEIVED_ATTRIBUTE_ID 0x04CC // Ver.: always +#define ZCL_CONSUMER_TOPUP_ACTIONED_ATTRIBUTE_ID 0x04CD // Ver.: always +#define ZCL_CONSUMER_TOPUP_CANCELLED_ATTRIBUTE_ID 0x04CE // Ver.: always +#define ZCL_CONSUMER_TOPUP_REJECTED_ATTRIBUTE_ID 0x04CF // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_RECEIVED_ATTRIBUTE_ID 0x04D0 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_ACTIONED_ATTRIBUTE_ID 0x04D1 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_CANCELLED_ATTRIBUTE_ID 0x04D2 // Ver.: always +#define ZCL_CREDIT_ADJUSTMENT_REJECTED_ATTRIBUTE_ID 0x04D3 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_RECEIVED_ATTRIBUTE_ID 0x04D4 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_ACTIONED_ATTRIBUTE_ID 0x04D5 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_CANCELLED_ATTRIBUTE_ID 0x04D6 // Ver.: always +#define ZCL_CHANGE_PAYMENT_MODE_REJECTED_ATTRIBUTE_ID 0x04D7 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_RECEIVED_ATTRIBUTE_ID 0x04D8 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_ACTIONED_ATTRIBUTE_ID 0x04D9 // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_CANCELLED_ATTRIBUTE_ID 0x04DA // Ver.: always +#define ZCL_GET_PREPAY_SNAPSHOT_REJECTED_ATTRIBUTE_ID 0x04DB // Ver.: always +#define ZCL_GET_TOPUP_LOG_RECEIVED_ATTRIBUTE_ID 0x04DC // Ver.: always +#define ZCL_GET_TOPUP_LOG_ACTIONED_ATTRIBUTE_ID 0x04DD // Ver.: always +#define ZCL_GET_TOPUP_LOG_CANCELLED_ATTRIBUTE_ID 0x04DE // Ver.: always +#define ZCL_GET_TOPUP_LOG_REJECTED_ATTRIBUTE_ID 0x04DF // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_RECEIVED_ATTRIBUTE_ID 0x04E0 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_ACTIONED_ATTRIBUTE_ID 0x04E1 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_CANCELLED_ATTRIBUTE_ID 0x04E2 // Ver.: always +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_REJECTED_ATTRIBUTE_ID 0x04E3 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_RECEIVED_ATTRIBUTE_ID 0x04E4 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_ACTIONED_ATTRIBUTE_ID 0x04E5 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_CANCELLED_ATTRIBUTE_ID 0x04E6 // Ver.: always +#define ZCL_GET_DEBT_REPAY_LOG_REJECTED_ATTRIBUTE_ID 0x04E7 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_RECEIVED_ATTRIBUTE_ID 0x04E8 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_ACTIONED_ATTRIBUTE_ID 0x04E9 // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_CANCELLED_ATTRIBUTE_ID 0x04EA // Ver.: always +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_REJECTED_ATTRIBUTE_ID 0x04EB // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_RECEIVED_ATTRIBUTE_ID 0x04EC // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_ACTIONED_ATTRIBUTE_ID 0x04ED // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_CANCELLED_ATTRIBUTE_ID 0x04EE // Ver.: always +#define ZCL_SET_OVERALL_DEBT_CAP_REJECTED_ATTRIBUTE_ID 0x04EF // Ver.: always +#define ZCL_CALENDAR_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_CALENDAR_CHANGE_PASSIVE_ACTIVATED_ATTRIBUTE_ID 0x0501 // Ver.: always +#define ZCL_CALENDAR_CHANGE_PASSIVE_UPDATED_ATTRIBUTE_ID 0x0502 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_RECEIVED_ATTRIBUTE_ID 0x05C0 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_ACTIONED_ATTRIBUTE_ID 0x05C1 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_CANCELLED_ATTRIBUTE_ID 0x05C2 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_REJECTED_ATTRIBUTE_ID 0x05C3 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C4 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C5 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05C6 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_REJECTED_ATTRIBUTE_ID 0x05C7 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_RECEIVED_ATTRIBUTE_ID 0x05C8 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_ACTIONED_ATTRIBUTE_ID 0x05C9 // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_CANCELLED_ATTRIBUTE_ID 0x05CA // Ver.: always +#define ZCL_PUBLISH_WEEK_PROFILE_REJECTED_ATTRIBUTE_ID 0x05CB // Ver.: always +#define ZCL_PUBLISH_SEASONS_RECEIVED_ATTRIBUTE_ID 0x05CC // Ver.: always +#define ZCL_PUBLISH_SEASONS_ACTIONED_ATTRIBUTE_ID 0x05CD // Ver.: always +#define ZCL_PUBLISH_SEASONS_CANCELLED_ATTRIBUTE_ID 0x05CE // Ver.: always +#define ZCL_PUBLISH_SEASONS_REJECTED_ATTRIBUTE_ID 0x05CF // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_RECEIVED_ATTRIBUTE_ID 0x05D0 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_ACTIONED_ATTRIBUTE_ID 0x05D1 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_CANCELLED_ATTRIBUTE_ID 0x05D2 // Ver.: always +#define ZCL_PUBLISH_SPECIAL_DAYS_REJECTED_ATTRIBUTE_ID 0x05D3 // Ver.: always +#define ZCL_PASSWORD_1_CHANGE_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_PASSWORD_2_CHANGE_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_PASSWORD_3_CHANGE_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_PASSWORD_4_CHANGE_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_EVENT_LOG_CLEARED_ATTRIBUTE_ID 0x0604 // Ver.: always +#define ZCL_ZIGBEE_APS_TIMEOUT_ATTRIBUTE_ID 0x0610 // Ver.: always +#define ZCL_ZIGBEE_IEEE_TRANSMISSION_FAILURE_OVER_THRESHOLD_ATTRIBUTE_ID 0x0611 // Ver.: always +#define ZCL_ZIGBEE_IEEE_FRAME_CHECK_SEQUENCE_THRESHOLD_ATTRIBUTE_ID 0x0612 // Ver.: always +#define ZCL_ERROR_CERTIFICATE_ATTRIBUTE_ID 0x0613 // Ver.: always +#define ZCL_ERROR_SIGNATURE_ATTRIBUTE_ID 0x0614 // Ver.: always +#define ZCL_ERROR_PROGRAM_STORAGE_ATTRIBUTE_ID 0x0615 // Ver.: always +#define ZCL_PUBLISH_COT_RECEIVED_ATTRIBUTE_ID 0x06C0 // Ver.: always +#define ZCL_PUBLISH_COT_ACTIONED_ATTRIBUTE_ID 0x06C1 // Ver.: always +#define ZCL_PUBLISH_COT_CANCELLED_ATTRIBUTE_ID 0x06C2 // Ver.: always +#define ZCL_PUBLISH_COT_REJECTED_ATTRIBUTE_ID 0x06C3 // Ver.: always +#define ZCL_PUBLISH_COS_RECEIVED_ATTRIBUTE_ID 0x06C4 // Ver.: always +#define ZCL_PUBLISH_COS_ACTIONED_ATTRIBUTE_ID 0x06C5 // Ver.: always +#define ZCL_PUBLISH_COS_CANCELLED_ATTRIBUTE_ID 0x06C6 // Ver.: always +#define ZCL_PUBLISH_COS_REJECTED_ATTRIBUTE_ID 0x06C7 // Ver.: always +#define ZCL_CHANGE_PASSWORD_RECEIVED_ATTRIBUTE_ID 0x06C8 // Ver.: always +#define ZCL_CHANGE_PASSWORD_ACTIONED_ATTRIBUTE_ID 0x06C9 // Ver.: always +#define ZCL_CHANGE_PASSWORD_CANCELLED_ATTRIBUTE_ID 0x06CA // Ver.: always +#define ZCL_CHANGE_PASSWORD_REJECTED_ATTRIBUTE_ID 0x06CB // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_RECEIVED_ATTRIBUTE_ID 0x06CC // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_ACTIONED_ATTRIBUTE_ID 0x06CD // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_CANCELLED_ATTRIBUTE_ID 0x06CE // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_REJECTED_ATTRIBUTE_ID 0x06CF // Ver.: always +#define ZCL_UPDATE_SITE_ID_RECEIVED_ATTRIBUTE_ID 0x06D0 // Ver.: always +#define ZCL_UPDATE_SITE_ID_ACTIONED_ATTRIBUTE_ID 0x06D1 // Ver.: always +#define ZCL_UPDATE_SITE_ID_CANCELLED_ATTRIBUTE_ID 0x06D2 // Ver.: always +#define ZCL_UPDATE_SITE_ID_REJECTED_ATTRIBUTE_ID 0x06D3 // Ver.: always +#define ZCL_UPDATE_CIN_RECEIVED_ATTRIBUTE_ID 0x06D4 // Ver.: always +#define ZCL_UPDATE_CIN_ACTIONED_ATTRIBUTE_ID 0x06D5 // Ver.: always +#define ZCL_UPDATE_CIN_CANCELLED_ATTRIBUTE_ID 0x06D6 // Ver.: always +#define ZCL_UPDATE_CIN_REJECTED_ATTRIBUTE_ID 0x06D7 // Ver.: always +#define ZCL_TUNNELING_CLUSTER_NOT_FOUND_ATTRIBUTE_ID 0x0700 // Ver.: always +#define ZCL_UNSUPPORTED_PROTOCOL_ATTRIBUTE_ID 0x0701 // Ver.: always +#define ZCL_INCORRECT_PROTOCOL_ATTRIBUTE_ID 0x0702 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C0 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C1 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C2 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C3 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C4 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C5 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C6 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07C7 // Ver.: always +#define ZCL_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07C8 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07C9 // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CA // Ver.: always +#define ZCL_TRANSFER_DATA_ERROR_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CB // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CC // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07CD // Ver.: always +#define ZCL_ACK_TRANSFER_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07CE // Ver.: always +#define ZCL_READY_DATA_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07CF // Ver.: always +#define ZCL_READY_DATA_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D0 // Ver.: always +#define ZCL_READY_DATA_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D1 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_RECEIVED_ATTRIBUTE_ID 0x07D2 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_REJECTED_ATTRIBUTE_ID 0x07D3 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_GENERATED_ATTRIBUTE_ID 0x07D4 // Ver.: always +#define ZCL_FIRMWARE_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0800 // Ver.: always +#define ZCL_FIRMWARE_ACTIVATED_ATTRIBUTE_ID 0x0801 // Ver.: always +#define ZCL_FIRMWARE_ACTIVATION_FAILURE_ATTRIBUTE_ID 0x0802 // Ver.: always +#define ZCL_PATCH_READY_FOR_ACTIVATION_ATTRIBUTE_ID 0x0803 // Ver.: always +#define ZCL_PATCH_ACTIVATED_ATTRIBUTE_ID 0x0804 // Ver.: always +#define ZCL_PATCH_FAILURE_ATTRIBUTE_ID 0x0805 // Ver.: always +#define ZCL_IMAGE_NOTIFY_COMMAND_RECEIVED_ATTRIBUTE_ID 0x08C0 // Ver.: always +#define ZCL_IMAGE_NOTIFY_COMMAND_REJECTED_ATTRIBUTE_ID 0x08C1 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C2 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C3 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C4 // Ver.: always +#define ZCL_IMAGE_BLOCK_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C5 // Ver.: always +#define ZCL_IMAGE_PAGE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C6 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08C7 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08C8 // Ver.: always +#define ZCL_UPGRADE_END_REQUEST_GENERATED_ATTRIBUTE_ID 0x08C9 // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CA // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CB // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_REQUEST_GENERATED_ATTRIBUTE_ID 0x08CC // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_RECEIVED_ATTRIBUTE_ID 0x08CD // Ver.: always +#define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_REJECTED_ATTRIBUTE_ID 0x08CE // Ver.: always +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_PROVIDER_NAME_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0110 // Ver.: always -#define ZCL_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0111 // Ver.: always -#define ZCL_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0112 // Ver.: always -#define ZCL_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0113 // Ver.: always -#define ZCL_RECEIVED_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0120 // Ver.: always -#define ZCL_RECEIVED_PROVIDER_NAME_ATTRIBUTE_ID 0x0121 // Ver.: always -#define ZCL_RECEIVED_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0122 // Ver.: always -#define ZCL_RECEIVED_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0130 // Ver.: always -#define ZCL_RECEIVED_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0131 // Ver.: always -#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0132 // Ver.: always -#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0133 // Ver.: always -#define ZCL_CHANGE_OF_TENANCY_UPDATE_DATE_TIME_ATTRIBUTE_ID 0x0200 // Ver.: always -#define ZCL_PROPOSED_TENANCY_CHANGE_CONTROL_ATTRIBUTE_ID 0x0201 // Ver.: always -#define ZCL_WAN_STATUS_ATTRIBUTE_ID 0x0300 // Ver.: always -#define ZCL_LOW_MEDIUM_THRESHOLD_ATTRIBUTE_ID 0x0400 // Ver.: always -#define ZCL_MEDIUM_HIGH_THRESHOLD_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_PROVIDER_NAME_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0113 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_ID_SERVER_ATTRIBUTE_ID 0x0120 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_NAME_ATTRIBUTE_ID 0x0121 // Ver.: always +#define ZCL_RECEIVED_PROVIDER_CONTACT_DETAILS_ATTRIBUTE_ID 0x0122 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_ID_ATTRIBUTE_ID 0x0130 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_NAME_ATTRIBUTE_ID 0x0131 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_DATE_TIME_ATTRIBUTE_ID 0x0132 // Ver.: always +#define ZCL_RECEIVED_PROPOSED_PROVIDER_CHANGE_CONTROL_ATTRIBUTE_ID 0x0133 // Ver.: always +#define ZCL_CHANGE_OF_TENANCY_UPDATE_DATE_TIME_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_PROPOSED_TENANCY_CHANGE_CONTROL_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_WAN_STATUS_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_LOW_MEDIUM_THRESHOLD_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_MEDIUM_HIGH_THRESHOLD_ATTRIBUTE_ID 0x0401 // Ver.: always #define ZCL_DEVICE_MANAGEMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DEVICE_MANAGEMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Events // Cluster specification level: se-1.2b-15-0131-02 @@ -4230,7 +4244,6 @@ #define ZCL_EVENTS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_EVENTS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: MDU Pairing // Cluster specification level: se-1.2b-15-0131-02 @@ -4242,7 +4255,6 @@ #define ZCL_MDU_PAIRING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_MDU_PAIRING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Sub-GHz // Cluster specification level: se-1.2b-15-0131-02 @@ -4251,29 +4263,27 @@ #define ZCL_SUB_GHZ_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SUB_GHZ_CLUSTER_CHANNEL_CHANGE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SUB_GHZ_CLUSTER_PAGE_28_CHANNEL_MASK_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SUB_GHZ_CLUSTER_PAGE_29_CHANNEL_MASK_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SUB_GHZ_CLUSTER_PAGE_30_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SUB_GHZ_CLUSTER_PAGE_31_CHANNEL_MASK_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_CHANNEL_CHANGE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_28_CHANNEL_MASK_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_29_CHANNEL_MASK_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_30_CHANNEL_MASK_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SUB_GHZ_CLUSTER_PAGE_31_CHANNEL_MASK_ATTRIBUTE_ID 0x0004 // Ver.: always #define ZCL_SUB_GHZ_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SUB_GHZ_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Key Establishment // Cluster specification level: zcl-7.0-07-5123-07 // Client attributes -#define ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_KEY_ESTABLISHMENT_CLUSTER_CLUSTER_REVISION_CLIENT_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_KEY_ESTABLISHMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_KEY_ESTABLISHMENT_SUITE_SERVER_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_KEY_ESTABLISHMENT_SUITE_SERVER_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_KEY_ESTABLISHMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_KEY_ESTABLISHMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Information // Cluster specification level: ta-1.0-07-5307-07 @@ -4282,16 +4292,15 @@ #define ZCL_INFORMATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_NODE_DESCRIPTION_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_DELIVERY_ENABLE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_PUSH_INFORMATION_TIMER_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ENABLE_SECURE_CONFIGURATION_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_NUMBER_OF_CONTENTS_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_CONTENT_ROOT_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_NODE_DESCRIPTION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DELIVERY_ENABLE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PUSH_INFORMATION_TIMER_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ENABLE_SECURE_CONFIGURATION_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_NUMBER_OF_CONTENTS_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_CONTENT_ROOT_ID_ATTRIBUTE_ID 0x0011 // Ver.: always #define ZCL_INFORMATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_INFORMATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Data Sharing // Cluster specification level: ta-1.0-07-5307-07 @@ -4300,12 +4309,11 @@ #define ZCL_DATA_SHARING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_DEVICE_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_DEVICE_DESCRIPTION_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DEVICE_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DEVICE_DESCRIPTION_ATTRIBUTE_ID 0x0001 // Ver.: always #define ZCL_DATA_SHARING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DATA_SHARING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Gaming // Cluster specification level: ta-1.0-07-5307-07 @@ -4314,30 +4322,29 @@ #define ZCL_GAMING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PLAYER_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_NB_OF_GAMES_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_LIST_OF_GAMES_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ANNOUNCEMENT_INTERVAL_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_GAME_ID_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_NAME_OF_GAME_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_GAME_MASTER_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_GAMING_STATUS_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_CURRENT_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_LIST_OF_CURRENT_PLAYERS_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_MAX_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_MIN_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_CURRENT_GAME_LEVEL_ATTRIBUTE_ID 0x0018 // Ver.: always -#define ZCL_SCORE_OF_THIS_PLAYER_ATTRIBUTE_ID 0x0019 // Ver.: always -#define ZCL_TIMER1_ATTRIBUTE_ID 0x001A // Ver.: always -#define ZCL_TIMER2_ATTRIBUTE_ID 0x001B // Ver.: always -#define ZCL_TIMER3_ATTRIBUTE_ID 0x001C // Ver.: always -#define ZCL_COUNTER1_ATTRIBUTE_ID 0x001D // Ver.: always -#define ZCL_COUNTER2_ATTRIBUTE_ID 0x001E // Ver.: always -#define ZCL_DOWNLOADABLE_ATTRIBUTE_ID 0x001F // Ver.: always +#define ZCL_PLAYER_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NB_OF_GAMES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LIST_OF_GAMES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ANNOUNCEMENT_INTERVAL_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_GAME_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_NAME_OF_GAME_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_GAME_MASTER_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_GAMING_STATUS_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_CURRENT_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_LIST_OF_CURRENT_PLAYERS_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_MAX_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_MIN_NB_OF_PLAYERS_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_CURRENT_GAME_LEVEL_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_SCORE_OF_THIS_PLAYER_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_TIMER1_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_TIMER2_ATTRIBUTE_ID 0x001B // Ver.: always +#define ZCL_TIMER3_ATTRIBUTE_ID 0x001C // Ver.: always +#define ZCL_COUNTER1_ATTRIBUTE_ID 0x001D // Ver.: always +#define ZCL_COUNTER2_ATTRIBUTE_ID 0x001E // Ver.: always +#define ZCL_DOWNLOADABLE_ATTRIBUTE_ID 0x001F // Ver.: always #define ZCL_GAMING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_GAMING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Data Rate Control // Cluster specification level: ta-1.0-07-5307-07 @@ -4346,13 +4353,12 @@ #define ZCL_DATA_RATE_CONTROL_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_AVERAGE_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_MAX_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_BANDWIDTH_REQUIREMENT_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_AVERAGE_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_MAX_LATENCY_REQUIREMENT_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_BANDWIDTH_REQUIREMENT_ATTRIBUTE_ID 0x0002 // Ver.: always #define ZCL_DATA_RATE_CONTROL_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DATA_RATE_CONTROL_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Voice over ZigBee // Cluster specification level: ta-1.0-07-5307-07 @@ -4361,21 +4367,20 @@ #define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_CODEC_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SAMPLING_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_CODEC_RATE_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_ESTABLISHMENT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_CODEC_TYPE_SUB1_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_CODEC_TYPE_SUB2_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_CODEC_TYPE_SUB3_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_COMPRESSION_TYPE_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_COMPRESSION_RATE_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_OPTION_FLAGS_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_THRESHOLD_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_CODEC_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAMPLING_FREQUENCY_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_CODEC_RATE_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_ESTABLISHMENT_TIMEOUT_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_CODEC_TYPE_SUB1_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_CODEC_TYPE_SUB2_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_CODEC_TYPE_SUB3_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_COMPRESSION_TYPE_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_COMPRESSION_RATE_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_OPTION_FLAGS_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_THRESHOLD_ATTRIBUTE_ID 0x000A // Ver.: always #define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Chatting // Cluster specification level: ta-1.0-07-5307-07 @@ -4384,15 +4389,14 @@ #define ZCL_CHATTING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_U_ID_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_NICKNAME_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_C_ID_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_NAME_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_ENABLE_ADD_CHAT_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_U_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_NICKNAME_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_C_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_NAME_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_ENABLE_ADD_CHAT_ATTRIBUTE_ID 0x0020 // Ver.: always #define ZCL_CHATTING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_CHATTING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Payment // Cluster specification level: ta-1.0-07-5307-07 @@ -4401,24 +4405,23 @@ #define ZCL_PAYMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PAYMENT_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_USER_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_PAYMENT_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_PAYMENT_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_TOTEM_ID_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_CURRENCY_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0021 // Ver.: always -#define ZCL_PRICE_ATTRIBUTE_ID 0x0022 // Ver.: always -#define ZCL_GOOD_ID_ATTRIBUTE_ID 0x0030 // Ver.: always -#define ZCL_SERIAL_NUMBER_ATTRIBUTE_ID 0x0031 // Ver.: always -#define ZCL_PAYMENT_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: always -#define ZCL_TRANS_ID_ATTRIBUTE_ID 0x0033 // Ver.: always -#define ZCL_TRANS_STATUS_ATTRIBUTE_ID 0x0034 // Ver.: always -#define ZCL_PAYMENT_STATUS_ATTRIBUTE_ID 0x0035 // Ver.: always +#define ZCL_PAYMENT_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_USER_TYPE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_PAYMENT_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_PAYMENT_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_TOTEM_ID_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_CURRENCY_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_PRICE_TRAILING_DIGIT_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_PRICE_ATTRIBUTE_ID 0x0022 // Ver.: always +#define ZCL_GOOD_ID_ATTRIBUTE_ID 0x0030 // Ver.: always +#define ZCL_SERIAL_NUMBER_ATTRIBUTE_ID 0x0031 // Ver.: always +#define ZCL_PAYMENT_TIMESTAMP_ATTRIBUTE_ID 0x0032 // Ver.: always +#define ZCL_TRANS_ID_ATTRIBUTE_ID 0x0033 // Ver.: always +#define ZCL_TRANS_STATUS_ATTRIBUTE_ID 0x0034 // Ver.: always +#define ZCL_PAYMENT_STATUS_ATTRIBUTE_ID 0x0035 // Ver.: always #define ZCL_PAYMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_PAYMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Billing // Cluster specification level: ta-1.0-07-5307-07 @@ -4427,16 +4430,15 @@ #define ZCL_BILLING_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_SESSION_INTERVAL_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_TIMESTAMP_ATTRIBUTE_ID 0x0020 // Ver.: always -#define ZCL_DURATION_ATTRIBUTE_ID 0x0021 // Ver.: always +#define ZCL_USER_ID_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SERVICE_ID_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SERVICE_PROVIDER_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SESSION_INTERVAL_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_TIMESTAMP_ATTRIBUTE_ID 0x0020 // Ver.: always +#define ZCL_DURATION_ATTRIBUTE_ID 0x0021 // Ver.: always #define ZCL_BILLING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_BILLING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Appliance Identification // Cluster specification level: UNKNOWN @@ -4445,22 +4447,21 @@ #define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_BASIC_IDENTIFICATION_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_APPLIANCE_COMPANY_NAME_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_COMPANY_ID_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_BRAND_NAME_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_BRAND_ID_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_APPLIANCE_MODEL_ATTRIBUTE_ID 0x0014 // Ver.: always -#define ZCL_APPLIANCE_PART_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always -#define ZCL_APPLIANCE_PRODUCT_REVISION_ATTRIBUTE_ID 0x0016 // Ver.: always -#define ZCL_APPLIANCE_SOFTWARE_REVISION_ATTRIBUTE_ID 0x0017 // Ver.: always -#define ZCL_PRODUCT_TYPE_NAME_ATTRIBUTE_ID 0x0018 // Ver.: always -#define ZCL_PRODUCT_TYPE_ID_ATTRIBUTE_ID 0x0019 // Ver.: always -#define ZCL_CECED_SPECIFICATION_VERSION_ATTRIBUTE_ID 0x001A // Ver.: always +#define ZCL_BASIC_IDENTIFICATION_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_APPLIANCE_COMPANY_NAME_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_COMPANY_ID_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_BRAND_NAME_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_BRAND_ID_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_APPLIANCE_MODEL_ATTRIBUTE_ID 0x0014 // Ver.: always +#define ZCL_APPLIANCE_PART_NUMBER_ATTRIBUTE_ID 0x0015 // Ver.: always +#define ZCL_APPLIANCE_PRODUCT_REVISION_ATTRIBUTE_ID 0x0016 // Ver.: always +#define ZCL_APPLIANCE_SOFTWARE_REVISION_ATTRIBUTE_ID 0x0017 // Ver.: always +#define ZCL_PRODUCT_TYPE_NAME_ATTRIBUTE_ID 0x0018 // Ver.: always +#define ZCL_PRODUCT_TYPE_ID_ATTRIBUTE_ID 0x0019 // Ver.: always +#define ZCL_CECED_SPECIFICATION_VERSION_ATTRIBUTE_ID 0x001A // Ver.: always #define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Meter Identification // Cluster specification level: UNKNOWN @@ -4469,22 +4470,21 @@ #define ZCL_METER_IDENTIFICATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_METER_COMPANY_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_METER_TYPE_ID_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_DATA_QUALITY_ID_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_CUSTOMER_NAME_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_METER_MODEL_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_METER_PART_NUMBER_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_METER_PRODUCT_REVISION_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_METER_SOFTWARE_REVISION_ATTRIBUTE_ID 0x000A // Ver.: always -#define ZCL_UTILITY_NAME_ATTRIBUTE_ID 0x000B // Ver.: always -#define ZCL_POD_ATTRIBUTE_ID 0x000C // Ver.: always -#define ZCL_AVAILABLE_POWER_ATTRIBUTE_ID 0x000D // Ver.: always -#define ZCL_POWER_THRESHOLD_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_METER_COMPANY_NAME_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_METER_TYPE_ID_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_DATA_QUALITY_ID_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_CUSTOMER_NAME_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_METER_MODEL_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_METER_PART_NUMBER_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_METER_PRODUCT_REVISION_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_METER_SOFTWARE_REVISION_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_UTILITY_NAME_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_POD_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_AVAILABLE_POWER_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_POWER_THRESHOLD_ATTRIBUTE_ID 0x000E // Ver.: always #define ZCL_METER_IDENTIFICATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_METER_IDENTIFICATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Appliance Events and Alert // Cluster specification level: UNKNOWN @@ -4496,7 +4496,6 @@ #define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Appliance Statistics // Cluster specification level: UNKNOWN @@ -4505,12 +4504,11 @@ #define ZCL_APPLIANCE_STATISTICS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_LOG_MAX_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_LOG_QUEUE_MAX_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_LOG_MAX_SIZE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_LOG_QUEUE_MAX_SIZE_ATTRIBUTE_ID 0x0001 // Ver.: always #define ZCL_APPLIANCE_STATISTICS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_APPLIANCE_STATISTICS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Electrical Measurement // Cluster specification level: UNKNOWN @@ -4519,138 +4517,137 @@ #define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_MEASUREMENT_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_DC_VOLTAGE_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_DC_VOLTAGE_MIN_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_DC_VOLTAGE_MAX_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_DC_CURRENT_ATTRIBUTE_ID 0x0103 // Ver.: always -#define ZCL_DC_CURRENT_MIN_ATTRIBUTE_ID 0x0104 // Ver.: always -#define ZCL_DC_CURRENT_MAX_ATTRIBUTE_ID 0x0105 // Ver.: always -#define ZCL_DC_POWER_ATTRIBUTE_ID 0x0106 // Ver.: always -#define ZCL_DC_POWER_MIN_ATTRIBUTE_ID 0x0107 // Ver.: always -#define ZCL_DC_POWER_MAX_ATTRIBUTE_ID 0x0108 // Ver.: always -#define ZCL_DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0200 // Ver.: always -#define ZCL_DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0201 // Ver.: always -#define ZCL_DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always -#define ZCL_DC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always -#define ZCL_DC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0204 // Ver.: always -#define ZCL_DC_POWER_DIVISOR_ATTRIBUTE_ID 0x0205 // Ver.: always -#define ZCL_AC_FREQUENCY_ATTRIBUTE_ID 0x0300 // Ver.: always -#define ZCL_AC_FREQUENCY_MIN_ATTRIBUTE_ID 0x0301 // Ver.: always -#define ZCL_AC_FREQUENCY_MAX_ATTRIBUTE_ID 0x0302 // Ver.: always -#define ZCL_NEUTRAL_CURRENT_ATTRIBUTE_ID 0x0303 // Ver.: always -#define ZCL_TOTAL_ACTIVE_POWER_ATTRIBUTE_ID 0x0304 // Ver.: always -#define ZCL_TOTAL_REACTIVE_POWER_ATTRIBUTE_ID 0x0305 // Ver.: always -#define ZCL_TOTAL_APPARENT_POWER_ATTRIBUTE_ID 0x0306 // Ver.: always -#define ZCL_MEASURED_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0307 // Ver.: always -#define ZCL_MEASURED_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0308 // Ver.: always -#define ZCL_MEASURED_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0309 // Ver.: always -#define ZCL_MEASURED_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030A // Ver.: always -#define ZCL_MEASURED_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030B // Ver.: always -#define ZCL_MEASURED_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030C // Ver.: always -#define ZCL_MEASURED_PHASE_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030D // Ver.: always -#define ZCL_MEASURED_PHASE_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030E // Ver.: always -#define ZCL_MEASURED_PHASE_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030F // Ver.: always -#define ZCL_MEASURED_PHASE_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0310 // Ver.: always -#define ZCL_MEASURED_PHASE_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0311 // Ver.: always -#define ZCL_MEASURED_PHASE_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0312 // Ver.: always -#define ZCL_AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID 0x0400 // Ver.: always -#define ZCL_AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID 0x0401 // Ver.: always -#define ZCL_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0402 // Ver.: always -#define ZCL_POWER_DIVISOR_ATTRIBUTE_ID 0x0403 // Ver.: always -#define ZCL_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0404 // Ver.: always -#define ZCL_PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0405 // Ver.: always -#define ZCL_INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID 0x0500 // Ver.: always -#define ZCL_INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID 0x0501 // Ver.: always -#define ZCL_INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID 0x0502 // Ver.: always -#define ZCL_INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID 0x0503 // Ver.: always -#define ZCL_INSTANTANEOUS_POWER_ATTRIBUTE_ID 0x0504 // Ver.: always -#define ZCL_RMS_VOLTAGE_ATTRIBUTE_ID 0x0505 // Ver.: always -#define ZCL_RMS_VOLTAGE_MIN_ATTRIBUTE_ID 0x0506 // Ver.: always -#define ZCL_RMS_VOLTAGE_MAX_ATTRIBUTE_ID 0x0507 // Ver.: always -#define ZCL_RMS_CURRENT_ATTRIBUTE_ID 0x0508 // Ver.: always -#define ZCL_RMS_CURRENT_MIN_ATTRIBUTE_ID 0x0509 // Ver.: always -#define ZCL_RMS_CURRENT_MAX_ATTRIBUTE_ID 0x050A // Ver.: always -#define ZCL_ACTIVE_POWER_ATTRIBUTE_ID 0x050B // Ver.: always -#define ZCL_ACTIVE_POWER_MIN_ATTRIBUTE_ID 0x050C // Ver.: always -#define ZCL_ACTIVE_POWER_MAX_ATTRIBUTE_ID 0x050D // Ver.: always -#define ZCL_REACTIVE_POWER_ATTRIBUTE_ID 0x050E // Ver.: always -#define ZCL_APPARENT_POWER_ATTRIBUTE_ID 0x050F // Ver.: always -#define ZCL_AC_POWER_FACTOR_ATTRIBUTE_ID 0x0510 // Ver.: always -#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0511 // Ver.: always -#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID 0x0513 // Ver.: always -#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0514 // Ver.: always -#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0515 // Ver.: always -#define ZCL_RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID 0x0516 // Ver.: always -#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID 0x0517 // Ver.: always -#define ZCL_AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0600 // Ver.: always -#define ZCL_AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0601 // Ver.: always -#define ZCL_AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0602 // Ver.: always -#define ZCL_AC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0603 // Ver.: always -#define ZCL_AC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0604 // Ver.: always -#define ZCL_AC_POWER_DIVISOR_ATTRIBUTE_ID 0x0605 // Ver.: always -#define ZCL_DC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0700 // Ver.: always -#define ZCL_DC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0701 // Ver.: always -#define ZCL_DC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0702 // Ver.: always -#define ZCL_AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0800 // Ver.: always -#define ZCL_AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0801 // Ver.: always -#define ZCL_AC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0802 // Ver.: always -#define ZCL_AC_POWER_OVERLOAD_ATTRIBUTE_ID 0x0803 // Ver.: always -#define ZCL_AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID 0x0804 // Ver.: always -#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID 0x0805 // Ver.: always -#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0806 // Ver.: always -#define ZCL_RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID 0x0807 // Ver.: always -#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0808 // Ver.: always -#define ZCL_RMS_VOLTAGE_SAG_ATTRIBUTE_ID 0x0809 // Ver.: always -#define ZCL_RMS_VOLTAGE_SWELL_ATTRIBUTE_ID 0x080A // Ver.: always -#define ZCL_LINE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0901 // Ver.: always -#define ZCL_ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0902 // Ver.: always -#define ZCL_REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0903 // Ver.: always -#define ZCL_RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID 0x0905 // Ver.: always -#define ZCL_RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID 0x0906 // Ver.: always -#define ZCL_RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID 0x0907 // Ver.: always -#define ZCL_RMS_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0908 // Ver.: always -#define ZCL_RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID 0x0909 // Ver.: always -#define ZCL_RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID 0x090A // Ver.: always -#define ZCL_ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090B // Ver.: always -#define ZCL_ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID 0x090C // Ver.: always -#define ZCL_ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID 0x090D // Ver.: always -#define ZCL_REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090E // Ver.: always -#define ZCL_APPARENT_POWER_PHASE_B_ATTRIBUTE_ID 0x090F // Ver.: always -#define ZCL_POWER_FACTOR_PHASE_B_ATTRIBUTE_ID 0x0910 // Ver.: always -#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0911 // Ver.: always -#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0912 // Ver.: always -#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0913 // Ver.: always -#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0914 // Ver.: always -#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0915 // Ver.: always -#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0916 // Ver.: always -#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0917 // Ver.: always -#define ZCL_LINE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A01 // Ver.: always -#define ZCL_ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A02 // Ver.: always -#define ZCL_REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A03 // Ver.: always -#define ZCL_RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID 0x0A05 // Ver.: always -#define ZCL_RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID 0x0A06 // Ver.: always -#define ZCL_RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID 0x0A07 // Ver.: always -#define ZCL_RMS_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A08 // Ver.: always -#define ZCL_RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID 0x0A09 // Ver.: always -#define ZCL_RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0A // Ver.: always -#define ZCL_ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0B // Ver.: always -#define ZCL_ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID 0x0A0C // Ver.: always -#define ZCL_ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0D // Ver.: always -#define ZCL_REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0E // Ver.: always -#define ZCL_APPARENT_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0F // Ver.: always -#define ZCL_POWER_FACTOR_PHASE_C_ATTRIBUTE_ID 0x0A10 // Ver.: always -#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A11 // Ver.: always -#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A12 // Ver.: always -#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A13 // Ver.: always -#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A14 // Ver.: always -#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A15 // Ver.: always -#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A16 // Ver.: always -#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A17 // Ver.: always +#define ZCL_MEASUREMENT_TYPE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_DC_VOLTAGE_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_DC_VOLTAGE_MIN_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_DC_VOLTAGE_MAX_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_DC_CURRENT_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_DC_CURRENT_MIN_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_DC_CURRENT_MAX_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_DC_POWER_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_DC_POWER_MIN_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_DC_POWER_MAX_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0200 // Ver.: always +#define ZCL_DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0201 // Ver.: always +#define ZCL_DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0202 // Ver.: always +#define ZCL_DC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0203 // Ver.: always +#define ZCL_DC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0204 // Ver.: always +#define ZCL_DC_POWER_DIVISOR_ATTRIBUTE_ID 0x0205 // Ver.: always +#define ZCL_AC_FREQUENCY_ATTRIBUTE_ID 0x0300 // Ver.: always +#define ZCL_AC_FREQUENCY_MIN_ATTRIBUTE_ID 0x0301 // Ver.: always +#define ZCL_AC_FREQUENCY_MAX_ATTRIBUTE_ID 0x0302 // Ver.: always +#define ZCL_NEUTRAL_CURRENT_ATTRIBUTE_ID 0x0303 // Ver.: always +#define ZCL_TOTAL_ACTIVE_POWER_ATTRIBUTE_ID 0x0304 // Ver.: always +#define ZCL_TOTAL_REACTIVE_POWER_ATTRIBUTE_ID 0x0305 // Ver.: always +#define ZCL_TOTAL_APPARENT_POWER_ATTRIBUTE_ID 0x0306 // Ver.: always +#define ZCL_MEASURED_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0307 // Ver.: always +#define ZCL_MEASURED_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0308 // Ver.: always +#define ZCL_MEASURED_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0309 // Ver.: always +#define ZCL_MEASURED_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030A // Ver.: always +#define ZCL_MEASURED_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030B // Ver.: always +#define ZCL_MEASURED_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030C // Ver.: always +#define ZCL_MEASURED_PHASE_1ST_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030D // Ver.: always +#define ZCL_MEASURED_PHASE_3RD_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030E // Ver.: always +#define ZCL_MEASURED_PHASE_5TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x030F // Ver.: always +#define ZCL_MEASURED_PHASE_7TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0310 // Ver.: always +#define ZCL_MEASURED_PHASE_9TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0311 // Ver.: always +#define ZCL_MEASURED_PHASE_11TH_HARMONIC_CURRENT_ATTRIBUTE_ID 0x0312 // Ver.: always +#define ZCL_AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID 0x0400 // Ver.: always +#define ZCL_AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID 0x0401 // Ver.: always +#define ZCL_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0402 // Ver.: always +#define ZCL_POWER_DIVISOR_ATTRIBUTE_ID 0x0403 // Ver.: always +#define ZCL_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0404 // Ver.: always +#define ZCL_PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0405 // Ver.: always +#define ZCL_INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID 0x0500 // Ver.: always +#define ZCL_INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID 0x0501 // Ver.: always +#define ZCL_INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID 0x0502 // Ver.: always +#define ZCL_INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID 0x0503 // Ver.: always +#define ZCL_INSTANTANEOUS_POWER_ATTRIBUTE_ID 0x0504 // Ver.: always +#define ZCL_RMS_VOLTAGE_ATTRIBUTE_ID 0x0505 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_ATTRIBUTE_ID 0x0506 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_ATTRIBUTE_ID 0x0507 // Ver.: always +#define ZCL_RMS_CURRENT_ATTRIBUTE_ID 0x0508 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_ATTRIBUTE_ID 0x0509 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_ATTRIBUTE_ID 0x050A // Ver.: always +#define ZCL_ACTIVE_POWER_ATTRIBUTE_ID 0x050B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_ATTRIBUTE_ID 0x050C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_ATTRIBUTE_ID 0x050D // Ver.: always +#define ZCL_REACTIVE_POWER_ATTRIBUTE_ID 0x050E // Ver.: always +#define ZCL_APPARENT_POWER_ATTRIBUTE_ID 0x050F // Ver.: always +#define ZCL_AC_POWER_FACTOR_ATTRIBUTE_ID 0x0510 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID 0x0511 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID 0x0513 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0514 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID 0x0515 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID 0x0516 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID 0x0517 // Ver.: always +#define ZCL_AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID 0x0600 // Ver.: always +#define ZCL_AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID 0x0601 // Ver.: always +#define ZCL_AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID 0x0602 // Ver.: always +#define ZCL_AC_CURRENT_DIVISOR_ATTRIBUTE_ID 0x0603 // Ver.: always +#define ZCL_AC_POWER_MULTIPLIER_ATTRIBUTE_ID 0x0604 // Ver.: always +#define ZCL_AC_POWER_DIVISOR_ATTRIBUTE_ID 0x0605 // Ver.: always +#define ZCL_DC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0700 // Ver.: always +#define ZCL_DC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0701 // Ver.: always +#define ZCL_DC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0702 // Ver.: always +#define ZCL_AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID 0x0800 // Ver.: always +#define ZCL_AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID 0x0801 // Ver.: always +#define ZCL_AC_CURRENT_OVERLOAD_ATTRIBUTE_ID 0x0802 // Ver.: always +#define ZCL_AC_POWER_OVERLOAD_ATTRIBUTE_ID 0x0803 // Ver.: always +#define ZCL_AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID 0x0804 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID 0x0805 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0806 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID 0x0807 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID 0x0808 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_ATTRIBUTE_ID 0x0809 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_ATTRIBUTE_ID 0x080A // Ver.: always +#define ZCL_LINE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0901 // Ver.: always +#define ZCL_ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0902 // Ver.: always +#define ZCL_REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0903 // Ver.: always +#define ZCL_RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID 0x0905 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID 0x0906 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID 0x0907 // Ver.: always +#define ZCL_RMS_CURRENT_PHASE_B_ATTRIBUTE_ID 0x0908 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID 0x0909 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID 0x090A // Ver.: always +#define ZCL_ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID 0x090C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID 0x090D // Ver.: always +#define ZCL_REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID 0x090E // Ver.: always +#define ZCL_APPARENT_POWER_PHASE_B_ATTRIBUTE_ID 0x090F // Ver.: always +#define ZCL_POWER_FACTOR_PHASE_B_ATTRIBUTE_ID 0x0910 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0911 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0912 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID 0x0913 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0914 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0915 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0916 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID 0x0917 // Ver.: always +#define ZCL_LINE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A01 // Ver.: always +#define ZCL_ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A02 // Ver.: always +#define ZCL_REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A03 // Ver.: always +#define ZCL_RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID 0x0A05 // Ver.: always +#define ZCL_RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID 0x0A06 // Ver.: always +#define ZCL_RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID 0x0A07 // Ver.: always +#define ZCL_RMS_CURRENT_PHASE_C_ATTRIBUTE_ID 0x0A08 // Ver.: always +#define ZCL_RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID 0x0A09 // Ver.: always +#define ZCL_RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0A // Ver.: always +#define ZCL_ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0B // Ver.: always +#define ZCL_ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID 0x0A0C // Ver.: always +#define ZCL_ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID 0x0A0D // Ver.: always +#define ZCL_REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0E // Ver.: always +#define ZCL_APPARENT_POWER_PHASE_C_ATTRIBUTE_ID 0x0A0F // Ver.: always +#define ZCL_POWER_FACTOR_PHASE_C_ATTRIBUTE_ID 0x0A10 // Ver.: always +#define ZCL_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A11 // Ver.: always +#define ZCL_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A12 // Ver.: always +#define ZCL_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID 0x0A13 // Ver.: always +#define ZCL_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A14 // Ver.: always +#define ZCL_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A15 // Ver.: always +#define ZCL_RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A16 // Ver.: always +#define ZCL_RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID 0x0A17 // Ver.: always #define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Diagnostics // Cluster specification level: UNKNOWN @@ -4659,42 +4656,41 @@ #define ZCL_DIAGNOSTICS_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_NUMBER_OF_RESETS_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_PERSISTENT_MEMORY_WRITES_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_MAC_RX_BCAST_ATTRIBUTE_ID 0x0100 // Ver.: always -#define ZCL_MAC_TX_BCAST_ATTRIBUTE_ID 0x0101 // Ver.: always -#define ZCL_MAC_RX_UCAST_ATTRIBUTE_ID 0x0102 // Ver.: always -#define ZCL_MAC_TX_UCAST_ATTRIBUTE_ID 0x0103 // Ver.: always -#define ZCL_MAC_TX_UCAST_RETRY_ATTRIBUTE_ID 0x0104 // Ver.: always -#define ZCL_MAC_TX_UCAST_FAIL_ATTRIBUTE_ID 0x0105 // Ver.: always -#define ZCL_APS_RX_BCAST_ATTRIBUTE_ID 0x0106 // Ver.: always -#define ZCL_APS_TX_BCAST_ATTRIBUTE_ID 0x0107 // Ver.: always -#define ZCL_APS_RX_UCAST_ATTRIBUTE_ID 0x0108 // Ver.: always -#define ZCL_APS_UCAST_SUCCESS_ATTRIBUTE_ID 0x0109 // Ver.: always -#define ZCL_APS_TX_UCAST_RETRY_ATTRIBUTE_ID 0x010A // Ver.: always -#define ZCL_APS_TX_UCAST_FAIL_ATTRIBUTE_ID 0x010B // Ver.: always -#define ZCL_ROUTE_DISC_INITIATED_ATTRIBUTE_ID 0x010C // Ver.: always -#define ZCL_NEIGHBOR_ADDED_ATTRIBUTE_ID 0x010D // Ver.: always -#define ZCL_NEIGHBOR_REMOVED_ATTRIBUTE_ID 0x010E // Ver.: always -#define ZCL_NEIGHBOR_STALE_ATTRIBUTE_ID 0x010F // Ver.: always -#define ZCL_JOIN_INDICATION_ATTRIBUTE_ID 0x0110 // Ver.: always -#define ZCL_CHILD_MOVED_ATTRIBUTE_ID 0x0111 // Ver.: always -#define ZCL_NWK_FC_FAILURE_ATTRIBUTE_ID 0x0112 // Ver.: always -#define ZCL_APS_FC_FAILURE_ATTRIBUTE_ID 0x0113 // Ver.: always -#define ZCL_APS_UNAUTHORIZED_KEY_ATTRIBUTE_ID 0x0114 // Ver.: always -#define ZCL_NWK_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0115 // Ver.: always -#define ZCL_APS_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0116 // Ver.: always -#define ZCL_PACKET_BUFFER_ALLOC_FAILURES_ATTRIBUTE_ID 0x0117 // Ver.: always -#define ZCL_RELAYED_UNICAST_ATTRIBUTE_ID 0x0118 // Ver.: always -#define ZCL_PHY_TO_MAC_QUEUE_LIMIT_REACHED_ATTRIBUTE_ID 0x0119 // Ver.: always -#define ZCL_PACKET_VALIDATE_DROP_COUNT_ATTRIBUTE_ID 0x011A // Ver.: always -#define ZCL_AVERAGE_MAC_RETRY_PER_APS_MSG_SENT_ATTRIBUTE_ID 0x011B // Ver.: always -#define ZCL_LAST_MESSAGE_LQI_ATTRIBUTE_ID 0x011C // Ver.: always -#define ZCL_LAST_MESSAGE_RSSI_ATTRIBUTE_ID 0x011D // Ver.: always +#define ZCL_NUMBER_OF_RESETS_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_PERSISTENT_MEMORY_WRITES_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_MAC_RX_BCAST_ATTRIBUTE_ID 0x0100 // Ver.: always +#define ZCL_MAC_TX_BCAST_ATTRIBUTE_ID 0x0101 // Ver.: always +#define ZCL_MAC_RX_UCAST_ATTRIBUTE_ID 0x0102 // Ver.: always +#define ZCL_MAC_TX_UCAST_ATTRIBUTE_ID 0x0103 // Ver.: always +#define ZCL_MAC_TX_UCAST_RETRY_ATTRIBUTE_ID 0x0104 // Ver.: always +#define ZCL_MAC_TX_UCAST_FAIL_ATTRIBUTE_ID 0x0105 // Ver.: always +#define ZCL_APS_RX_BCAST_ATTRIBUTE_ID 0x0106 // Ver.: always +#define ZCL_APS_TX_BCAST_ATTRIBUTE_ID 0x0107 // Ver.: always +#define ZCL_APS_RX_UCAST_ATTRIBUTE_ID 0x0108 // Ver.: always +#define ZCL_APS_UCAST_SUCCESS_ATTRIBUTE_ID 0x0109 // Ver.: always +#define ZCL_APS_TX_UCAST_RETRY_ATTRIBUTE_ID 0x010A // Ver.: always +#define ZCL_APS_TX_UCAST_FAIL_ATTRIBUTE_ID 0x010B // Ver.: always +#define ZCL_ROUTE_DISC_INITIATED_ATTRIBUTE_ID 0x010C // Ver.: always +#define ZCL_NEIGHBOR_ADDED_ATTRIBUTE_ID 0x010D // Ver.: always +#define ZCL_NEIGHBOR_REMOVED_ATTRIBUTE_ID 0x010E // Ver.: always +#define ZCL_NEIGHBOR_STALE_ATTRIBUTE_ID 0x010F // Ver.: always +#define ZCL_JOIN_INDICATION_ATTRIBUTE_ID 0x0110 // Ver.: always +#define ZCL_CHILD_MOVED_ATTRIBUTE_ID 0x0111 // Ver.: always +#define ZCL_NWK_FC_FAILURE_ATTRIBUTE_ID 0x0112 // Ver.: always +#define ZCL_APS_FC_FAILURE_ATTRIBUTE_ID 0x0113 // Ver.: always +#define ZCL_APS_UNAUTHORIZED_KEY_ATTRIBUTE_ID 0x0114 // Ver.: always +#define ZCL_NWK_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0115 // Ver.: always +#define ZCL_APS_DECRYPT_FAILURE_ATTRIBUTE_ID 0x0116 // Ver.: always +#define ZCL_PACKET_BUFFER_ALLOC_FAILURES_ATTRIBUTE_ID 0x0117 // Ver.: always +#define ZCL_RELAYED_UNICAST_ATTRIBUTE_ID 0x0118 // Ver.: always +#define ZCL_PHY_TO_MAC_QUEUE_LIMIT_REACHED_ATTRIBUTE_ID 0x0119 // Ver.: always +#define ZCL_PACKET_VALIDATE_DROP_COUNT_ATTRIBUTE_ID 0x011A // Ver.: always +#define ZCL_AVERAGE_MAC_RETRY_PER_APS_MSG_SENT_ATTRIBUTE_ID 0x011B // Ver.: always +#define ZCL_LAST_MESSAGE_LQI_ATTRIBUTE_ID 0x011C // Ver.: always +#define ZCL_LAST_MESSAGE_RSSI_ATTRIBUTE_ID 0x011D // Ver.: always #define ZCL_DIAGNOSTICS_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_DIAGNOSTICS_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: ZLL Commissioning // Cluster specification level: zll-1.0-11-0037-10 @@ -4706,7 +4702,6 @@ #define ZCL_ZLL_COMMISSIONING_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_ZLL_COMMISSIONING_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Sample Mfg Specific Cluster // Cluster specification level: UNKNOWN @@ -4715,12 +4710,11 @@ #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ATTRIBUTE_ONE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ATTRIBUTE_TWO_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ATTRIBUTE_ONE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ATTRIBUTE_TWO_ATTRIBUTE_ID 0x0001 // Ver.: always #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Sample Mfg Specific Cluster 2 // Cluster specification level: UNKNOWN @@ -4729,12 +4723,11 @@ #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_ATTRIBUTE_THREE_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_ATTRIBUTE_FOUR_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_ATTRIBUTE_THREE_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_ATTRIBUTE_FOUR_ATTRIBUTE_ID 0x0001 // Ver.: always #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: Configuration Cluster // Cluster specification level: UNKNOWN @@ -4743,11 +4736,10 @@ #define ZCL_OTA_CONFIGURATION_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_TOKENS_LOCKED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_TOKENS_LOCKED_ATTRIBUTE_ID 0x0000 // Ver.: always #define ZCL_OTA_CONFIGURATION_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_OTA_CONFIGURATION_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: MFGLIB Cluster // Cluster specification level: UNKNOWN @@ -4756,13 +4748,12 @@ #define ZCL_MFGLIB_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_PACKETS_RECEIVED_ATTRIBUTE_ID 0x0000 // Ver.: always -#define ZCL_SAVED_RSSI_ATTRIBUTE_ID 0x0001 // Ver.: always -#define ZCL_SAVED_LQI_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_PACKETS_RECEIVED_ATTRIBUTE_ID 0x0000 // Ver.: always +#define ZCL_SAVED_RSSI_ATTRIBUTE_ID 0x0001 // Ver.: always +#define ZCL_SAVED_LQI_ATTRIBUTE_ID 0x0002 // Ver.: always #define ZCL_MFGLIB_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 #define ZCL_MFGLIB_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - // Attribute types for cluster: SL Works With All Hubs // Cluster specification level: UNKNOWN @@ -4771,26 +4762,25 @@ #define ZCL_SL_WWAH_CLUSTER_REPORTING_STATUS_CLIENT_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 // Server attributes -#define ZCL_SL_DISABLE_OTA_DOWNGRADES_ATTRIBUTE_ID 0x0002 // Ver.: always -#define ZCL_SL_MGMT_LEAVE_WITHOUT_REJOIN_ENABLED_ATTRIBUTE_ID 0x0003 // Ver.: always -#define ZCL_SL_NWK_RETRY_COUNT_ATTRIBUTE_ID 0x0004 // Ver.: always -#define ZCL_SL_MAC_RETRY_COUNT_ATTRIBUTE_ID 0x0005 // Ver.: always -#define ZCL_SL_ROUTER_CHECKIN_ENABLED_ATTRIBUTE_ID 0x0006 // Ver.: always -#define ZCL_SL_TOUCHLINK_INTERPAN_ENABLED_ATTRIBUTE_ID 0x0007 // Ver.: always -#define ZCL_SL_WWAH_PARENT_CLASSIFICATION_ENABLED_ATTRIBUTE_ID 0x0008 // Ver.: always -#define ZCL_SL_WWAH_APP_EVENT_RETRY_ENABLED_ATTRIBUTE_ID 0x0009 // Ver.: always -#define ZCL_SL_WWAH_APP_EVENT_RETRY_QUEUE_SIZE_ATTRIBUTE_ID 0x000A // Ver.: always -#define ZCL_SL_WWAH_REJOIN_ENABLED_ATTRIBUTE_ID 0x000B // Ver.: always -#define ZCL_SL_MAC_POLL_FAILURE_WAIT_TIME_ATTRIBUTE_ID 0x000C // Ver.: always -#define ZCL_SL_CONFIGURATION_MODE_ENABLED_ATTRIBUTE_ID 0x000D // Ver.: always -#define ZCL_SL_CURRENT_DEBUG_REPORT_ID_ATTRIBUTE_ID 0x000E // Ver.: always +#define ZCL_SL_DISABLE_OTA_DOWNGRADES_ATTRIBUTE_ID 0x0002 // Ver.: always +#define ZCL_SL_MGMT_LEAVE_WITHOUT_REJOIN_ENABLED_ATTRIBUTE_ID 0x0003 // Ver.: always +#define ZCL_SL_NWK_RETRY_COUNT_ATTRIBUTE_ID 0x0004 // Ver.: always +#define ZCL_SL_MAC_RETRY_COUNT_ATTRIBUTE_ID 0x0005 // Ver.: always +#define ZCL_SL_ROUTER_CHECKIN_ENABLED_ATTRIBUTE_ID 0x0006 // Ver.: always +#define ZCL_SL_TOUCHLINK_INTERPAN_ENABLED_ATTRIBUTE_ID 0x0007 // Ver.: always +#define ZCL_SL_WWAH_PARENT_CLASSIFICATION_ENABLED_ATTRIBUTE_ID 0x0008 // Ver.: always +#define ZCL_SL_WWAH_APP_EVENT_RETRY_ENABLED_ATTRIBUTE_ID 0x0009 // Ver.: always +#define ZCL_SL_WWAH_APP_EVENT_RETRY_QUEUE_SIZE_ATTRIBUTE_ID 0x000A // Ver.: always +#define ZCL_SL_WWAH_REJOIN_ENABLED_ATTRIBUTE_ID 0x000B // Ver.: always +#define ZCL_SL_MAC_POLL_FAILURE_WAIT_TIME_ATTRIBUTE_ID 0x000C // Ver.: always +#define ZCL_SL_CONFIGURATION_MODE_ENABLED_ATTRIBUTE_ID 0x000D // Ver.: always +#define ZCL_SL_CURRENT_DEBUG_REPORT_ID_ATTRIBUTE_ID 0x000E // Ver.: always #define ZCL_SL_TC_SECURITY_ON_NTWK_KEY_ROTATION_ENABLED_ATTRIBUTE_ID 0x000F // Ver.: always -#define ZCL_SL_WWAH_BAD_PARENT_RECOVERY_ENABLED_ATTRIBUTE_ID 0x0010 // Ver.: always -#define ZCL_SL_PENDING_NETWORK_UPDATE_CHANNEL_ATTRIBUTE_ID 0x0011 // Ver.: always -#define ZCL_SL_PENDING_NETWORK_UPDATE_PANID_ATTRIBUTE_ID 0x0012 // Ver.: always -#define ZCL_SL_OTA_MAX_OFFLINE_DURATION_ATTRIBUTE_ID 0x0013 // Ver.: always -#define ZCL_SL_WWAH_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 -#define ZCL_SL_WWAH_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 - +#define ZCL_SL_WWAH_BAD_PARENT_RECOVERY_ENABLED_ATTRIBUTE_ID 0x0010 // Ver.: always +#define ZCL_SL_PENDING_NETWORK_UPDATE_CHANNEL_ATTRIBUTE_ID 0x0011 // Ver.: always +#define ZCL_SL_PENDING_NETWORK_UPDATE_PANID_ATTRIBUTE_ID 0x0012 // Ver.: always +#define ZCL_SL_OTA_MAX_OFFLINE_DURATION_ATTRIBUTE_ID 0x0013 // Ver.: always +#define ZCL_SL_WWAH_CLUSTER_CLUSTER_REVISION_SERVER_ATTRIBUTE_ID 0xFFFD // Ver.: since zcl-6.0-15-02017-001 +#define ZCL_SL_WWAH_CLUSTER_REPORTING_STATUS_SERVER_ATTRIBUTE_ID 0xFFFE // Ver.: since zcl-6.0-15-02017-001 #endif // SILABS_EMBER_AF_ATTRIBUTE_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-size.h b/examples/wifi-echo/server/esp32/main/gen/attribute-size.h index e84131dfeef166..8ab0dae3944631 100644 --- a/examples/wifi-echo/server/esp32/main/gen/attribute-size.h +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-size.h @@ -39,30 +39,11 @@ #ifndef SILABS_ATTRIBUTE_SIZE #define SILABS_ATTRIBUTE_SIZE - // Used ZCL attribute type sizes - ZCL_BITMAP16_ATTRIBUTE_TYPE, 2, - ZCL_BITMAP24_ATTRIBUTE_TYPE, 3, - ZCL_BITMAP32_ATTRIBUTE_TYPE, 4, - ZCL_BITMAP48_ATTRIBUTE_TYPE, 6, - ZCL_BITMAP64_ATTRIBUTE_TYPE, 8, - ZCL_BITMAP8_ATTRIBUTE_TYPE, 1, - ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, - ZCL_DATA8_ATTRIBUTE_TYPE, 1, - ZCL_ENUM16_ATTRIBUTE_TYPE, 2, - ZCL_ENUM8_ATTRIBUTE_TYPE, 1, - ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE, 4, - ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE, 8, - ZCL_INT16S_ATTRIBUTE_TYPE, 2, - ZCL_INT16U_ATTRIBUTE_TYPE, 2, - ZCL_INT24S_ATTRIBUTE_TYPE, 3, - ZCL_INT24U_ATTRIBUTE_TYPE, 3, - ZCL_INT32S_ATTRIBUTE_TYPE, 4, - ZCL_INT32U_ATTRIBUTE_TYPE, 4, - ZCL_INT48U_ATTRIBUTE_TYPE, 6, - ZCL_INT56U_ATTRIBUTE_TYPE, 7, - ZCL_INT8S_ATTRIBUTE_TYPE, 1, - ZCL_INT8U_ATTRIBUTE_TYPE, 1, - ZCL_SECURITY_KEY_ATTRIBUTE_TYPE, 16, - ZCL_UTC_TIME_ATTRIBUTE_TYPE, 4, +ZCL_BITMAP16_ATTRIBUTE_TYPE, 2, ZCL_BITMAP24_ATTRIBUTE_TYPE, 3, ZCL_BITMAP32_ATTRIBUTE_TYPE, 4, ZCL_BITMAP48_ATTRIBUTE_TYPE, 6, + ZCL_BITMAP64_ATTRIBUTE_TYPE, 8, ZCL_BITMAP8_ATTRIBUTE_TYPE, 1, ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, ZCL_DATA8_ATTRIBUTE_TYPE, 1, + ZCL_ENUM16_ATTRIBUTE_TYPE, 2, ZCL_ENUM8_ATTRIBUTE_TYPE, 1, ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE, 4, ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE, + 8, ZCL_INT16S_ATTRIBUTE_TYPE, 2, ZCL_INT16U_ATTRIBUTE_TYPE, 2, ZCL_INT24S_ATTRIBUTE_TYPE, 3, ZCL_INT24U_ATTRIBUTE_TYPE, 3, + ZCL_INT32S_ATTRIBUTE_TYPE, 4, ZCL_INT32U_ATTRIBUTE_TYPE, 4, ZCL_INT48U_ATTRIBUTE_TYPE, 6, ZCL_INT56U_ATTRIBUTE_TYPE, 7, + ZCL_INT8S_ATTRIBUTE_TYPE, 1, ZCL_INT8U_ATTRIBUTE_TYPE, 1, ZCL_SECURITY_KEY_ATTRIBUTE_TYPE, 16, ZCL_UTC_TIME_ATTRIBUTE_TYPE, 4, #endif // SILABS_ATTRIBUTE_SIZE diff --git a/examples/wifi-echo/server/esp32/main/gen/attribute-type.h b/examples/wifi-echo/server/esp32/main/gen/attribute-type.h index d817c5d2889b19..35879dabb2ed6e 100644 --- a/examples/wifi-echo/server/esp32/main/gen/attribute-type.h +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-type.h @@ -39,65 +39,65 @@ #ifndef SILABS_EMBER_AF_ATTRIBUTE_TYPES #define SILABS_EMBER_AF_ATTRIBUTE_TYPES - // ZCL attribute types -enum { - ZCL_NO_DATA_ATTRIBUTE_TYPE = 0x00, // No data - ZCL_DATA8_ATTRIBUTE_TYPE = 0x08, // 8-bit data - ZCL_DATA16_ATTRIBUTE_TYPE = 0x09, // 16-bit data - ZCL_DATA24_ATTRIBUTE_TYPE = 0x0A, // 24-bit data - ZCL_DATA32_ATTRIBUTE_TYPE = 0x0B, // 32-bit data - ZCL_DATA40_ATTRIBUTE_TYPE = 0x0C, // 40-bit data - ZCL_DATA48_ATTRIBUTE_TYPE = 0x0D, // 48-bit data - ZCL_DATA56_ATTRIBUTE_TYPE = 0x0E, // 56-bit data - ZCL_DATA64_ATTRIBUTE_TYPE = 0x0F, // 64-bit data - ZCL_BOOLEAN_ATTRIBUTE_TYPE = 0x10, // Boolean - ZCL_BITMAP8_ATTRIBUTE_TYPE = 0x18, // 8-bit bitmap - ZCL_BITMAP16_ATTRIBUTE_TYPE = 0x19, // 16-bit bitmap - ZCL_BITMAP24_ATTRIBUTE_TYPE = 0x1A, // 24-bit bitmap - ZCL_BITMAP32_ATTRIBUTE_TYPE = 0x1B, // 32-bit bitmap - ZCL_BITMAP40_ATTRIBUTE_TYPE = 0x1C, // 40-bit bitmap - ZCL_BITMAP48_ATTRIBUTE_TYPE = 0x1D, // 48-bit bitmap - ZCL_BITMAP56_ATTRIBUTE_TYPE = 0x1E, // 56-bit bitmap - ZCL_BITMAP64_ATTRIBUTE_TYPE = 0x1F, // 64-bit bitmap - ZCL_INT8U_ATTRIBUTE_TYPE = 0x20, // Unsigned 8-bit integer - ZCL_INT16U_ATTRIBUTE_TYPE = 0x21, // Unsigned 16-bit integer - ZCL_INT24U_ATTRIBUTE_TYPE = 0x22, // Unsigned 24-bit integer - ZCL_INT32U_ATTRIBUTE_TYPE = 0x23, // Unsigned 32-bit integer - ZCL_INT40U_ATTRIBUTE_TYPE = 0x24, // Unsigned 40-bit integer - ZCL_INT48U_ATTRIBUTE_TYPE = 0x25, // Unsigned 48-bit integer - ZCL_INT56U_ATTRIBUTE_TYPE = 0x26, // Unsigned 56-bit integer - ZCL_INT64U_ATTRIBUTE_TYPE = 0x27, // Unsigned 64-bit integer - ZCL_INT8S_ATTRIBUTE_TYPE = 0x28, // Signed 8-bit integer - ZCL_INT16S_ATTRIBUTE_TYPE = 0x29, // Signed 16-bit integer - ZCL_INT24S_ATTRIBUTE_TYPE = 0x2A, // Signed 24-bit integer - ZCL_INT32S_ATTRIBUTE_TYPE = 0x2B, // Signed 32-bit integer - ZCL_INT40S_ATTRIBUTE_TYPE = 0x2C, // Signed 40-bit integer - ZCL_INT48S_ATTRIBUTE_TYPE = 0x2D, // Signed 48-bit integer - ZCL_INT56S_ATTRIBUTE_TYPE = 0x2E, // Signed 56-bit integer - ZCL_INT64S_ATTRIBUTE_TYPE = 0x2F, // Signed 64-bit integer - ZCL_ENUM8_ATTRIBUTE_TYPE = 0x30, // 8-bit enumeration - ZCL_ENUM16_ATTRIBUTE_TYPE = 0x31, // 16-bit enumeration - ZCL_FLOAT_SEMI_ATTRIBUTE_TYPE = 0x38, // Semi-precision - ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE = 0x39, // Single precision - ZCL_FLOAT_DOUBLE_ATTRIBUTE_TYPE = 0x3A, // Double precision - ZCL_OCTET_STRING_ATTRIBUTE_TYPE = 0x41, // Octet string - ZCL_CHAR_STRING_ATTRIBUTE_TYPE = 0x42, // Character string - ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE = 0x43, // Long octet string - ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE = 0x44, // Long character string - ZCL_ARRAY_ATTRIBUTE_TYPE = 0x48, // Array - ZCL_STRUCT_ATTRIBUTE_TYPE = 0x4C, // Structure - ZCL_SET_ATTRIBUTE_TYPE = 0x50, // Set - ZCL_BAG_ATTRIBUTE_TYPE = 0x51, // Bag - ZCL_TIME_OF_DAY_ATTRIBUTE_TYPE = 0xE0, // Time of day - ZCL_DATE_ATTRIBUTE_TYPE = 0xE1, // Date - ZCL_UTC_TIME_ATTRIBUTE_TYPE = 0xE2, // UTC Time - ZCL_CLUSTER_ID_ATTRIBUTE_TYPE = 0xE8, // Cluster ID - ZCL_ATTRIBUTE_ID_ATTRIBUTE_TYPE = 0xE9, // Attribute ID - ZCL_BACNET_OID_ATTRIBUTE_TYPE = 0xEA, // BACnet OID - ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE = 0xF0, // IEEE address - ZCL_SECURITY_KEY_ATTRIBUTE_TYPE = 0xF1, // 128-bit security key - ZCL_UNKNOWN_ATTRIBUTE_TYPE = 0xFF // Unknown +enum +{ + ZCL_NO_DATA_ATTRIBUTE_TYPE = 0x00, // No data + ZCL_DATA8_ATTRIBUTE_TYPE = 0x08, // 8-bit data + ZCL_DATA16_ATTRIBUTE_TYPE = 0x09, // 16-bit data + ZCL_DATA24_ATTRIBUTE_TYPE = 0x0A, // 24-bit data + ZCL_DATA32_ATTRIBUTE_TYPE = 0x0B, // 32-bit data + ZCL_DATA40_ATTRIBUTE_TYPE = 0x0C, // 40-bit data + ZCL_DATA48_ATTRIBUTE_TYPE = 0x0D, // 48-bit data + ZCL_DATA56_ATTRIBUTE_TYPE = 0x0E, // 56-bit data + ZCL_DATA64_ATTRIBUTE_TYPE = 0x0F, // 64-bit data + ZCL_BOOLEAN_ATTRIBUTE_TYPE = 0x10, // Boolean + ZCL_BITMAP8_ATTRIBUTE_TYPE = 0x18, // 8-bit bitmap + ZCL_BITMAP16_ATTRIBUTE_TYPE = 0x19, // 16-bit bitmap + ZCL_BITMAP24_ATTRIBUTE_TYPE = 0x1A, // 24-bit bitmap + ZCL_BITMAP32_ATTRIBUTE_TYPE = 0x1B, // 32-bit bitmap + ZCL_BITMAP40_ATTRIBUTE_TYPE = 0x1C, // 40-bit bitmap + ZCL_BITMAP48_ATTRIBUTE_TYPE = 0x1D, // 48-bit bitmap + ZCL_BITMAP56_ATTRIBUTE_TYPE = 0x1E, // 56-bit bitmap + ZCL_BITMAP64_ATTRIBUTE_TYPE = 0x1F, // 64-bit bitmap + ZCL_INT8U_ATTRIBUTE_TYPE = 0x20, // Unsigned 8-bit integer + ZCL_INT16U_ATTRIBUTE_TYPE = 0x21, // Unsigned 16-bit integer + ZCL_INT24U_ATTRIBUTE_TYPE = 0x22, // Unsigned 24-bit integer + ZCL_INT32U_ATTRIBUTE_TYPE = 0x23, // Unsigned 32-bit integer + ZCL_INT40U_ATTRIBUTE_TYPE = 0x24, // Unsigned 40-bit integer + ZCL_INT48U_ATTRIBUTE_TYPE = 0x25, // Unsigned 48-bit integer + ZCL_INT56U_ATTRIBUTE_TYPE = 0x26, // Unsigned 56-bit integer + ZCL_INT64U_ATTRIBUTE_TYPE = 0x27, // Unsigned 64-bit integer + ZCL_INT8S_ATTRIBUTE_TYPE = 0x28, // Signed 8-bit integer + ZCL_INT16S_ATTRIBUTE_TYPE = 0x29, // Signed 16-bit integer + ZCL_INT24S_ATTRIBUTE_TYPE = 0x2A, // Signed 24-bit integer + ZCL_INT32S_ATTRIBUTE_TYPE = 0x2B, // Signed 32-bit integer + ZCL_INT40S_ATTRIBUTE_TYPE = 0x2C, // Signed 40-bit integer + ZCL_INT48S_ATTRIBUTE_TYPE = 0x2D, // Signed 48-bit integer + ZCL_INT56S_ATTRIBUTE_TYPE = 0x2E, // Signed 56-bit integer + ZCL_INT64S_ATTRIBUTE_TYPE = 0x2F, // Signed 64-bit integer + ZCL_ENUM8_ATTRIBUTE_TYPE = 0x30, // 8-bit enumeration + ZCL_ENUM16_ATTRIBUTE_TYPE = 0x31, // 16-bit enumeration + ZCL_FLOAT_SEMI_ATTRIBUTE_TYPE = 0x38, // Semi-precision + ZCL_FLOAT_SINGLE_ATTRIBUTE_TYPE = 0x39, // Single precision + ZCL_FLOAT_DOUBLE_ATTRIBUTE_TYPE = 0x3A, // Double precision + ZCL_OCTET_STRING_ATTRIBUTE_TYPE = 0x41, // Octet string + ZCL_CHAR_STRING_ATTRIBUTE_TYPE = 0x42, // Character string + ZCL_LONG_OCTET_STRING_ATTRIBUTE_TYPE = 0x43, // Long octet string + ZCL_LONG_CHAR_STRING_ATTRIBUTE_TYPE = 0x44, // Long character string + ZCL_ARRAY_ATTRIBUTE_TYPE = 0x48, // Array + ZCL_STRUCT_ATTRIBUTE_TYPE = 0x4C, // Structure + ZCL_SET_ATTRIBUTE_TYPE = 0x50, // Set + ZCL_BAG_ATTRIBUTE_TYPE = 0x51, // Bag + ZCL_TIME_OF_DAY_ATTRIBUTE_TYPE = 0xE0, // Time of day + ZCL_DATE_ATTRIBUTE_TYPE = 0xE1, // Date + ZCL_UTC_TIME_ATTRIBUTE_TYPE = 0xE2, // UTC Time + ZCL_CLUSTER_ID_ATTRIBUTE_TYPE = 0xE8, // Cluster ID + ZCL_ATTRIBUTE_ID_ATTRIBUTE_TYPE = 0xE9, // Attribute ID + ZCL_BACNET_OID_ATTRIBUTE_TYPE = 0xEA, // BACnet OID + ZCL_IEEE_ADDRESS_ATTRIBUTE_TYPE = 0xF0, // IEEE address + ZCL_SECURITY_KEY_ATTRIBUTE_TYPE = 0xF1, // 128-bit security key + ZCL_UNKNOWN_ATTRIBUTE_TYPE = 0xFF // Unknown }; #endif // SILABS_EMBER_AF_ATTRIBUTE_TYPES diff --git a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c index e5c460890b6556..c3753adcd622f4 100644 --- a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c @@ -38,17 +38,15 @@ // This is a set of generated functions that parse the // the incomming message, and call appropriate command handler. - - // #include PLATFORM_HEADER #ifdef EZSP_HOST // Includes needed for ember related functions for the EZSP host -#include "stack/include/error.h" -#include "stack/include/ember-types.h" #include "app/util/ezsp/ezsp-protocol.h" -#include "app/util/ezsp/ezsp.h" #include "app/util/ezsp/ezsp-utils.h" +#include "app/util/ezsp/ezsp.h" #include "app/util/ezsp/serial-interface.h" +#include "stack/include/ember-types.h" +#include "stack/include/error.h" #else // Includes needed for ember related functions for the EM250 // #include "stack/include/ember.h" @@ -59,81 +57,87 @@ #include "../util.h" #include "af-structs.h" #include "call-command-handler.h" -#include "command-id.h" #include "callback.h" +#include "command-id.h" static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific) { - if (wasHandled) { - return EMBER_ZCL_STATUS_SUCCESS; - } else if (mfgSpecific) { - return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND; - } else if (clusterExists) { - return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; - } else { - return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER; - } + if (wasHandled) + { + return EMBER_ZCL_STATUS_SUCCESS; + } + else if (mfgSpecific) + { + return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND; + } + else if (clusterExists) + { + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; + } + else + { + return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER; + } } // Main command parsing controller. -EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand *cmd) +EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd) { - EmberAfStatus result = status(false, false, cmd->mfgSpecific); - if (cmd->direction == (uint8_t)ZCL_DIRECTION_SERVER_TO_CLIENT - && emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, - cmd->apsFrame->clusterId, - cmd->mfgCode)) { - switch (cmd->apsFrame->clusterId) { - default: - // Unrecognized cluster ID, error status will apply. - break; + EmberAfStatus result = status(false, false, cmd->mfgSpecific); + if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT && + emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode)) + { + switch (cmd->apsFrame->clusterId) + { + default: + // Unrecognized cluster ID, error status will apply. + break; + } } - } else if (cmd->direction == (uint8_t)ZCL_DIRECTION_CLIENT_TO_SERVER - && emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, - cmd->apsFrame->clusterId, - cmd->mfgCode)) { - switch (cmd->apsFrame->clusterId) { - case ZCL_ON_OFF_CLUSTER_ID: - result = emberAfOnOffClusterServerCommandParse(cmd); - break; - default: - // Unrecognized cluster ID, error status will apply. - break; + else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER && + emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode)) + { + switch (cmd->apsFrame->clusterId) + { + case ZCL_ON_OFF_CLUSTER_ID: + result = emberAfOnOffClusterServerCommandParse(cmd); + break; + default: + // Unrecognized cluster ID, error status will apply. + break; + } } - } - return result; + return result; } // Cluster: On/off, server -EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand *cmd) +EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd) { - bool wasHandled = false; - if (!cmd->mfgSpecific) { - switch (cmd->commandId) { - case ZCL_OFF_COMMAND_ID: - { - // Command is fixed length: 0 - wasHandled = emberAfOnOffClusterOffCallback(); - break; - } - case ZCL_ON_COMMAND_ID: - { - // Command is fixed length: 0 - wasHandled = emberAfOnOffClusterOnCallback(); - break; - } - case ZCL_TOGGLE_COMMAND_ID: - { - // Command is fixed length: 0 - wasHandled = emberAfOnOffClusterToggleCallback(); - break; - } - default: - { - // Unrecognized command ID, error status will apply. - break; - } + bool wasHandled = false; + if (!cmd->mfgSpecific) + { + switch (cmd->commandId) + { + case ZCL_OFF_COMMAND_ID: { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterOffCallback(); + break; + } + case ZCL_ON_COMMAND_ID: { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterOnCallback(); + break; + } + case ZCL_TOGGLE_COMMAND_ID: { + // Command is fixed length: 0 + wasHandled = emberAfOnOffClusterToggleCallback(); + break; + } + default: { + // Unrecognized command ID, error status will apply. + break; + } + } } - } - return status(wasHandled, true, cmd->mfgSpecific); + return status(wasHandled, true, cmd->mfgSpecific); } diff --git a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h index 6c290b42e36d62..c1019c157ed9fd 100644 --- a/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h @@ -39,11 +39,10 @@ #ifndef SILABS_EMBER_AF_COMMAND_PARSE_HEADER #define SILABS_EMBER_AF_COMMAND_PARSE_HEADER - // This is a set of generated prototype for functions that parse the // the incomming message, and call appropriate command handler. // Cluster: On/off, server -EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand *cmd); +EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd); #endif // SILABS_EMBER_AF_COMMAND_PARSE_HEADER diff --git a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c index ce6bffe1e4ac8e..6d5b53ebdafcf4 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -38,13 +38,11 @@ // This c file provides stubs for all callbacks. These stubs // will be used in the case where user defined implementations // of the callbacks have not been provided. -#include #include "../af.h" +#include //#include "hal/hal.h" //#include EMBER_AF_API_NETWORK_STEERING - - /** @brief Add To Current App Tasks * * This function is only useful to sleepy end devices. This function will note @@ -56,9 +54,7 @@ * * @param tasks Ver.: always */ -void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks) -{ -} +void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks) {} /** @brief Allow Network Write Attribute * @@ -93,15 +89,11 @@ void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks) * @param value Ver.: always * @param type Ver.: always */ -EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* value, - uint8_t type) +EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t * value, uint8_t type) { - return EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL; // Default + return EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL; // Default } /** @brief Attribute Read Access @@ -114,12 +106,10 @@ EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_ * @param manufacturerCode Ver.: always * @param attributeId Ver.: always */ -bool emberAfAttributeReadAccessCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint16_t manufacturerCode, +bool emberAfAttributeReadAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, uint16_t attributeId) { - return true; + return true; } /** @brief Attribute Write Access @@ -132,12 +122,10 @@ bool emberAfAttributeReadAccessCallback(uint8_t endpoint, * @param manufacturerCode Ver.: always * @param attributeId Ver.: always */ -bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint16_t manufacturerCode, +bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, uint16_t attributeId) { - return true; + return true; } /** @brief Groups Cluster Clear Group Table @@ -147,9 +135,7 @@ bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, * * @param endpoint The endpoint. Ver.: always */ -void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint) -{ -} +void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint) {} /** @brief Clear Report Table * @@ -159,7 +145,7 @@ void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint) */ EmberStatus emberAfClearReportTableCallback(void) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Scenes Cluster ClearSceneTable @@ -169,9 +155,7 @@ EmberStatus emberAfClearReportTableCallback(void) * * @param endpoint The endpoint. Ver.: always */ -void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint) -{ -} +void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint) {} /** @brief Key Establishment Cluster Client Command Received * @@ -183,9 +167,9 @@ void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint) * * @param cmd Ver.: always */ -bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand *cmd) +bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand * cmd) { - return false; + return false; } /** @brief Cluster Init @@ -197,10 +181,7 @@ bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterC * @param endpoint Ver.: always * @param clusterId Ver.: always */ -void emberAfClusterInitCallback(uint8_t endpoint, - EmberAfClusterId clusterId) -{ -} +void emberAfClusterInitCallback(uint8_t endpoint, EmberAfClusterId clusterId) {} /** @brief Cluster Security Custom * @@ -215,13 +196,10 @@ void emberAfClusterInitCallback(uint8_t endpoint, * always * @param commandId The ZCL command ID being sent/received. Ver.: always */ -bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, - EmberAfClusterId clusterId, - bool incoming, - uint8_t commandId) +bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, EmberAfClusterId clusterId, bool incoming, uint8_t commandId) { - // By default, assume APS encryption is not required. - return false; + // By default, assume APS encryption is not required. + return false; } /** @brief Configure Reporting Command @@ -234,9 +212,9 @@ bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, * * @param cmd Ver.: always */ -bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd) +bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand * cmd) { - return false; + return false; } /** @brief Configure Reporting Response @@ -251,11 +229,9 @@ bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd) * always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen) +bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return false; + return false; } /** @brief Default Response @@ -270,11 +246,9 @@ bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, * @param status Specifies either SUCCESS or the nature of the error that was * detected in the received command. Ver.: always */ -bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status) +bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, uint8_t commandId, EmberAfStatus status) { - return false; + return false; } /** @brief Discover Attributes Response @@ -297,13 +271,10 @@ bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, * @param extended Indicates whether the response is in the extended format or * not. Ver.: always */ -bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, - bool discoveryComplete, - uint8_t *buffer, - uint16_t bufLen, - bool extended) +bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, bool discoveryComplete, uint8_t * buffer, + uint16_t bufLen, bool extended) { - return false; + return false; } /** @brief Discover Commands Generated Response @@ -320,13 +291,10 @@ bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, * @param commandIdCount The length of bytes of the list, whish is the same as * the number of identifiers. Ver.: always */ -bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, - uint16_t manufacturerCode, - bool discoveryComplete, - uint8_t *commandIds, - uint16_t commandIdCount) +bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount) { - return false; + return false; } /** @brief Discover Commands Received Response @@ -343,13 +311,10 @@ bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId * @param commandIdCount The length of bytes of the list, whish is the same as * the number of identifiers. Ver.: always */ -bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, - uint16_t manufacturerCode, - bool discoveryComplete, - uint8_t *commandIds, - uint16_t commandIdCount) +bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount) { - return false; + return false; } /** @brief Eeprom Init @@ -357,9 +322,7 @@ bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, * Tells the system to initialize the EEPROM if it is not already initialized. * */ -void emberAfEepromInitCallback(void) -{ -} +void emberAfEepromInitCallback(void) {} /** @brief Eeprom Note Initialized State * @@ -369,18 +332,14 @@ void emberAfEepromInitCallback(void) * @param state The state of the EEPROM, false=re-initalization needed, * true=no-re-init needed Ver.: always */ -void emberAfEepromNoteInitializedStateCallback(bool state) -{ -} +void emberAfEepromNoteInitializedStateCallback(bool state) {} /** @brief Eeprom Shutdown * * Tells the system to shutdown the EEPROM if it is not already shutdown. * */ -void emberAfEepromShutdownCallback(void) -{ -} +void emberAfEepromShutdownCallback(void) {} /** @brief Groups Cluster Endpoint In Group * @@ -391,10 +350,9 @@ void emberAfEepromShutdownCallback(void) * @param endpoint The endpoint. Ver.: always * @param groupId The group identifier. Ver.: always */ -bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, - uint16_t groupId) +bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, uint16_t groupId) { - return false; + return false; } /** @brief External Attribute Read @@ -433,14 +391,11 @@ bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, * @param buffer Ver.: always * @param maxReadLength Ver.: always */ -EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *attributeMetadata, - uint16_t manufacturerCode, - uint8_t *buffer, - uint16_t maxReadLength) +EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer, uint16_t maxReadLength) { - return EMBER_ZCL_STATUS_FAILURE; + return EMBER_ZCL_STATUS_FAILURE; } /** @brief External Attribute Write @@ -489,13 +444,11 @@ EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, * @param manufacturerCode Ver.: always * @param buffer Ver.: always */ -EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *attributeMetadata, - uint16_t manufacturerCode, - uint8_t *buffer) +EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer) { - return EMBER_ZCL_STATUS_FAILURE; + return EMBER_ZCL_STATUS_FAILURE; } /** @brief Find Unused Pan Id And Form @@ -507,7 +460,7 @@ EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, */ EmberStatus emberAfFindUnusedPanIdAndFormCallback(void) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Get Current App Tasks @@ -519,7 +472,7 @@ EmberStatus emberAfFindUnusedPanIdAndFormCallback(void) */ EmberAfApplicationTask emberAfGetCurrentAppTasksCallback(void) { - return 0; + return 0; } /** @brief Get Current Poll Control @@ -533,7 +486,7 @@ EmberAfApplicationTask emberAfGetCurrentAppTasksCallback(void) */ EmberAfEventPollControl emberAfGetCurrentPollControlCallback(void) { - return EMBER_AF_LONG_POLL; + return EMBER_AF_LONG_POLL; } /** @brief Get Current Poll Interval Ms @@ -546,7 +499,7 @@ EmberAfEventPollControl emberAfGetCurrentPollControlCallback(void) */ uint32_t emberAfGetCurrentPollIntervalMsCallback(void) { - return 0; + return 0; } /** @brief Get Current Poll Interval Qs @@ -559,7 +512,7 @@ uint32_t emberAfGetCurrentPollIntervalMsCallback(void) */ uint32_t emberAfGetCurrentPollIntervalQsCallback(void) { - return 0; + return 0; } /** @brief Get Current Sleep Control @@ -573,7 +526,7 @@ uint32_t emberAfGetCurrentPollIntervalQsCallback(void) */ EmberAfEventSleepControl emberAfGetCurrentSleepControlCallback(void) { - return EMBER_AF_OK_TO_SLEEP; + return EMBER_AF_OK_TO_SLEEP; } /** @brief Get Current Time @@ -587,7 +540,7 @@ EmberAfEventSleepControl emberAfGetCurrentSleepControlCallback(void) */ uint32_t emberAfGetCurrentTimeCallback(void) { - return 0; + return 0; } /** @brief Get Default Poll Control @@ -599,7 +552,7 @@ uint32_t emberAfGetCurrentTimeCallback(void) */ EmberAfEventPollControl emberAfGetDefaultPollControlCallback(void) { - return EMBER_AF_LONG_POLL; + return EMBER_AF_LONG_POLL; } /** @brief Get Default Sleep Control @@ -611,7 +564,7 @@ EmberAfEventPollControl emberAfGetDefaultPollControlCallback(void) */ EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void) { - return EMBER_AF_OK_TO_SLEEP; + return EMBER_AF_OK_TO_SLEEP; } /** @brief Get Endpoint By Index @@ -619,7 +572,7 @@ EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void) * Get the endpoint number based on the passed index. By default the framework * handles this by managing endpoints based on the precompiled configuration * defined in AppBuilder. This callback can override this behavior at runtime - * and provide additional endpoints or different data than the compiled values. + * and provide additional endpoints or different data than the compiled values. * If the index is overridden than the callback shall return true and set the * endpointReturn parameter accordingly. A value of 0xFF means the endpoint * doesn't exist at that index. @@ -630,10 +583,9 @@ EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void) * @param index The index of the endpoint. Ver.: always * @param endpointReturn The value of endpoint. Ver.: always */ -bool emberAfGetEndpointByIndexCallback(uint8_t index, - uint8_t* endpointReturn) +bool emberAfGetEndpointByIndexCallback(uint8_t index, uint8_t * endpointReturn) { - return false; + return false; } /** @brief Get Endpoint Description @@ -652,10 +604,9 @@ bool emberAfGetEndpointByIndexCallback(uint8_t index, * information is written if the callback is providing the information. Ver.: * always */ -bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, - EmberEndpointDescription* result) +bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, EmberEndpointDescription * result) { - return false; + return false; } /** @brief Get Endpoint Info @@ -675,11 +626,9 @@ bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, * @param returnEndpointInfo A pointer to a data struct that will be written * with information about the endpoint. Ver.: always */ -bool emberAfGetEndpointInfoCallback(uint8_t endpoint, - uint8_t* returnNetworkIndex, - EmberAfEndpointInfoStruct* returnEndpointInfo) +bool emberAfGetEndpointInfoCallback(uint8_t endpoint, uint8_t * returnNetworkIndex, EmberAfEndpointInfoStruct * returnEndpointInfo) { - return false; + return false; } /** @brief Get Form And Join Extended Pan Id @@ -691,9 +640,7 @@ bool emberAfGetEndpointInfoCallback(uint8_t endpoint, * * @param resultLocation Ver.: always */ -void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t *resultLocation) -{ -} +void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t * resultLocation) {} /** @brief Get Long Poll Interval Ms * @@ -705,7 +652,7 @@ void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t *resultLocation) */ uint32_t emberAfGetLongPollIntervalMsCallback(void) { - return 0; + return 0; } /** @brief Get Long Poll Interval Qs @@ -718,33 +665,33 @@ uint32_t emberAfGetLongPollIntervalMsCallback(void) */ uint32_t emberAfGetLongPollIntervalQsCallback(void) { - return 0; + return 0; } /** @brief Get Short Poll Interval Ms * * This function is only useful to sleepy end devices. This function will - * return the short poll interval (in milliseconds) for the current network. + * return the short poll interval (in milliseconds) for the current network. * This interval is the maximum amount of time a child will wait between polls * of its parent when it is expecting data. * */ uint16_t emberAfGetShortPollIntervalMsCallback(void) { - return 0; + return 0; } /** @brief Get Short Poll Interval Qs * * This function is only useful to sleepy end devices. This function will - * return the short poll interval (in quarter seconds) for the current network. + * return the short poll interval (in quarter seconds) for the current network. * This interval is the maximum amount of time a child will wait between polls * of its parent when it is expecting data. * */ uint16_t emberAfGetShortPollIntervalQsCallback(void) { - return 0; + return 0; } /** @brief Get Source Route Overhead @@ -756,7 +703,7 @@ uint16_t emberAfGetShortPollIntervalQsCallback(void) */ uint8_t emberAfGetSourceRouteOverheadCallback(EmberNodeId destination) { - return 0; + return 0; } /** @brief Get Wake Timeout Bitmask @@ -769,7 +716,7 @@ uint8_t emberAfGetSourceRouteOverheadCallback(EmberNodeId destination) */ EmberAfApplicationTask emberAfGetWakeTimeoutBitmaskCallback(void) { - return 0; + return 0; } /** @brief Get Wake Timeout Ms @@ -782,7 +729,7 @@ EmberAfApplicationTask emberAfGetWakeTimeoutBitmaskCallback(void) */ uint16_t emberAfGetWakeTimeoutMsCallback(void) { - return 0; + return 0; } /** @brief Get Wake Timeout Qs @@ -795,7 +742,7 @@ uint16_t emberAfGetWakeTimeoutMsCallback(void) */ uint16_t emberAfGetWakeTimeoutQsCallback(void) { - return 0; + return 0; } /** @brief Hal Button Isr @@ -809,10 +756,7 @@ uint16_t emberAfGetWakeTimeoutQsCallback(void) * either ::BUTTON_PRESSED if the button has been pressed or ::BUTTON_RELEASED * if the button has been released. Ver.: always */ -void emberAfHalButtonIsrCallback(uint8_t button, - uint8_t state) -{ -} +void emberAfHalButtonIsrCallback(uint8_t button, uint8_t state) {} /** @brief Incoming Packet Filter * @@ -839,12 +783,10 @@ void emberAfHalButtonIsrCallback(uint8_t button, * @param size_p a pointer containing the size value of the packet Ver.: always * @param data auxillary data included with the packet Ver.: always */ -EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, - uint8_t* packetData, - uint8_t* size_p, - void* data) +EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data) { - return EMBER_ACCEPT_PACKET; + return EMBER_ACCEPT_PACKET; } /** @brief Initiate Inter Pan Key Establishment @@ -858,10 +800,9 @@ EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType pack * @param panId The PAN id of the remote device. Ver.: always * @param eui64 The EUI64 of the remote device. Ver.: always */ -EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, - const EmberEUI64 eui64) +EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, const EmberEUI64 eui64) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Initiate Key Establishment @@ -874,10 +815,9 @@ EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, * @param nodeId The node id of the remote device. Ver.: always * @param endpoint The endpoint on the remote device. Ver.: always */ -EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, - uint8_t endpoint) +EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, uint8_t endpoint) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Initiate Partner Link Key Exchange @@ -894,16 +834,15 @@ EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, * @param callback The callback that should be called when the partner link key * exchange completse. Ver.: always */ -EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, - uint8_t endpoint, - EmberAfPartnerLinkKeyExchangeCallback *callback) +EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback * callback) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Inter Pan Key Establishment * - * A callback by the key-establishment code to indicate an event has occurred. + * A callback by the key-establishment code to indicate an event has occurred. * For error codes this is purely a notification. For non-error status codes * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or * disallow the operation. If the application returns true then the key @@ -916,13 +855,10 @@ EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, * @param eui64 Ver.: always * @param delayInSeconds Ver.: always */ -bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, - bool amInitiator, - EmberPanId panId, - const EmberEUI64 eui64, - uint8_t delayInSeconds) +bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberPanId panId, + const EmberEUI64 eui64, uint8_t delayInSeconds) { - return true; + return true; } /** @brief Interpan Send Message @@ -935,16 +871,14 @@ bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessag * always * @param message The message data received or to send. Ver.: always */ -EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, - uint16_t messageLength, - uint8_t* message) +EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Key Establishment * - * A callback by the key-establishment code to indicate an event has occurred. + * A callback by the key-establishment code to indicate an event has occurred. * For error codes this is purely a notification. For non-error status codes * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or * disallow the operation. If the application returns true then the key @@ -956,12 +890,10 @@ EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, * @param partnerShortId Ver.: always * @param delayInSeconds Ver.: always */ -bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, - bool amInitiator, - EmberNodeId partnerShortId, +bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberNodeId partnerShortId, uint8_t delayInSeconds) { - return true; + return true; } /** @brief On/off Cluster Level Control Effect @@ -973,10 +905,7 @@ bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status * @param endpoint Ver.: always * @param newValue Ver.: always */ -void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, - bool newValue) -{ -} +void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, bool newValue) {} /** @brief Main Init * @@ -998,9 +927,7 @@ void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, * Application Framework itself. * */ -void emberAfMainInitCallback(void) -{ -} +void emberAfMainInitCallback(void) {} /** @brief Main Start * @@ -1017,15 +944,13 @@ void emberAfMainInitCallback(void) * @param argc Ver.: always * @param argv Ver.: always */ -bool emberAfMainStartCallback(int* returnCode, - int argc, - char** argv) +bool emberAfMainStartCallback(int * returnCode, int argc, char ** argv) { - // NOTE: argc and argv may not be supported on all platforms, so argv MUST be - // checked for NULL before referencing it. On those platforms without argc - // and argv "0" and "NULL" are passed respectively. + // NOTE: argc and argv may not be supported on all platforms, so argv MUST be + // checked for NULL before referencing it. On those platforms without argc + // and argv "0" and "NULL" are passed respectively. - return false; // exit? + return false; // exit? } /** @brief Main Tick @@ -1034,9 +959,7 @@ bool emberAfMainStartCallback(int* returnCode, * end of the main tick execution. * */ -void emberAfMainTickCallback(void) -{ -} +void emberAfMainTickCallback(void) {} /** @brief Scenes Cluster Make Invalid * @@ -1047,7 +970,7 @@ void emberAfMainTickCallback(void) */ EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint) { - return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; } /** @brief Mark Buffers @@ -1058,7 +981,7 @@ EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint) */ void emberAfMarkBuffersCallback(void) { - //emMarkBuffer(&bufferUsed); + // emMarkBuffer(&bufferUsed); } /** @brief Message Sent @@ -1079,14 +1002,10 @@ void emberAfMarkBuffersCallback(void) * @param message Ver.: always * @param status Ver.: always */ -bool emberAfMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame* apsFrame, - uint16_t msgLen, - uint8_t* message, - EmberStatus status) +bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status) { - return false; + return false; } /** @brief Ncp Init @@ -1104,9 +1023,7 @@ bool emberAfMessageSentCallback(EmberOutgoingMessageType type, * * @param memoryAllocation Ver.: always */ -void emberAfNcpInitCallback(bool memoryAllocation) -{ -} +void emberAfNcpInitCallback(bool memoryAllocation) {} /** @brief Ncp Is Awake Isr * @@ -1115,9 +1032,7 @@ void emberAfNcpInitCallback(bool memoryAllocation) * function. * */ -void emberAfNcpIsAwakeIsrCallback(void) -{ -} +void emberAfNcpIsAwakeIsrCallback(void) {} /** @brief Network Key Update Complete * @@ -1126,9 +1041,7 @@ void emberAfNcpIsAwakeIsrCallback(void) * * @param status Ver.: always */ -void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status) -{ -} +void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status) {} /** @brief Ota Bootload * @@ -1140,12 +1053,11 @@ void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status) * @param ncpUpgradeTagId The tag ID of the upgrade data that will be used to * bootload the device. Ver.: always */ -uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, - uint16_t ncpUpgradeTagId) +uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId * id, uint16_t ncpUpgradeTagId) { - // Please implement me - emberAfCorePrintln("Not supported."); - return 1; + // Please implement me + emberAfCorePrintln("Not supported."); + return 1; } /** @brief Ota Client Bootload @@ -1157,11 +1069,11 @@ uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, * @param id This is the identifier relating to the image that has been * downloaded and is ready for bootload. Ver.: always */ -void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id) +void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId * id) { - // Any final preperation prior to the bootload should be done here. - // It is assumed that the device will reset in most all cases. - // Please implement me. + // Any final preperation prior to the bootload should be done here. + // It is assumed that the device will reset in most all cases. + // Please implement me. } /** @brief Ota Client Custom Verify @@ -1174,22 +1086,21 @@ void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id) * started. Ver.: always * @param id This is ID of the image to be verified. Ver.: always */ -EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, - const EmberAfOtaImageId* id) +EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, const EmberAfOtaImageId * id) { - // Manufacturing specific checks can be made to the image in this function to - // determine if it is valid. This function is called AFTER cryptographic - // checks have passed. If the cryptographic checks failed, this function will - // never be called. - - // The function shall return one of the following based on its own - // verification process. - // 1) EMBER_AF_IMAGE_GOOD - the image has passed all checks - // 2) EMBER_AF_IMAGE_BAD - the image is not valid - // 3) EMBER_AF_IMAGE_VERIFY_IN_PROGRESS - the image is valid so far, but more - // checks are needed. This callback shall be re-executed later to - // continue verification. This allows other code in the framework to run. - return EMBER_AF_IMAGE_GOOD; + // Manufacturing specific checks can be made to the image in this function to + // determine if it is valid. This function is called AFTER cryptographic + // checks have passed. If the cryptographic checks failed, this function will + // never be called. + + // The function shall return one of the following based on its own + // verification process. + // 1) EMBER_AF_IMAGE_GOOD - the image has passed all checks + // 2) EMBER_AF_IMAGE_BAD - the image is not valid + // 3) EMBER_AF_IMAGE_VERIFY_IN_PROGRESS - the image is valid so far, but more + // checks are needed. This callback shall be re-executed later to + // continue verification. This allows other code in the framework to run. + return EMBER_AF_IMAGE_GOOD; } /** @brief Ota Client Download Complete @@ -1207,23 +1118,23 @@ EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerificati * @param id This is the image identifier information that corresponds to the * download result. Ver.: always */ -bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, - const EmberAfOtaImageId* id) +bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, const EmberAfOtaImageId * id) { - // At this point the image has been completely downloaded and cryptographic - // checks (if applicable) have been performed. + // At this point the image has been completely downloaded and cryptographic + // checks (if applicable) have been performed. + + if (!success) + { + emberAfOtaBootloadClusterPrintln("Download failed."); + return true; // return value is ignored + } + + // This is for any additional validation that needs to be performed + // on the image by the application. - if (!success) { - emberAfOtaBootloadClusterPrintln("Download failed."); - return true; // return value is ignored - } - - // This is for any additional validation that needs to be performed - // on the image by the application. - - // The results of checks here will be returned back to the OTA server - // in the Upgrade End request. - return true; + // The results of checks here will be returned back to the OTA server + // in the Upgrade End request. + return true; } /** @brief Ota Client Incoming Message Raw @@ -1235,9 +1146,9 @@ bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, * @param message A pointer to the structure containing the message buffer and * other information about it. Ver.: always */ -bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand *message) +bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand * message) { - return false; + return false; } /** @brief Ota Client Start @@ -1248,9 +1159,7 @@ bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand *message) * for the bootload message, and kick off the bootload. * */ -void emberAfOtaClientStartCallback(void) -{ -} +void emberAfOtaClientStartCallback(void) {} /** @brief Ota Client Version Info * @@ -1267,34 +1176,33 @@ void emberAfOtaClientStartCallback(void) * the query. If no hardware version should be used, then * EMBER_AF_INVALID_HARDWARE_VERSION should be used. Ver.: always */ -void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId* currentImageInfo, - uint16_t* hardwareVersion) +void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId * currentImageInfo, uint16_t * hardwareVersion) { - // Customer will fill in the image info with their manufacturer ID, - // image type ID, and current software version number. - // The deviceSpecificFileEui64 can be ignored. + // Customer will fill in the image info with their manufacturer ID, + // image type ID, and current software version number. + // The deviceSpecificFileEui64 can be ignored. - // It may be necessary to dynamically determine this by talking to - // another device, as is the case with a host talking to an NCP device. + // It may be necessary to dynamically determine this by talking to + // another device, as is the case with a host talking to an NCP device. - // However, this routine will be called repeatedly so it may be wise - // to cache the data! + // However, this routine will be called repeatedly so it may be wise + // to cache the data! -/* This is commented out since the #defines below are not defined. + /* This is commented out since the #defines below are not defined. - if (currentImageInfo != NULL) { - MEMSET(currentImageInfo, 0, sizeof(EmberAfOtaImageId)); - currentImageInfo->manufacturerId = EMBER_AF_MANUFACTURER_CODE; - currentImageInfo->imageTypeId = EMBER_AF_IMAGE_TYPE_ID; - currentImageInfo->firmwareVersion = EMBER_AF_CUSTOM_FIRMWARE_VERSION; - } + if (currentImageInfo != NULL) { + MEMSET(currentImageInfo, 0, sizeof(EmberAfOtaImageId)); + currentImageInfo->manufacturerId = EMBER_AF_MANUFACTURER_CODE; + currentImageInfo->imageTypeId = EMBER_AF_IMAGE_TYPE_ID; + currentImageInfo->firmwareVersion = EMBER_AF_CUSTOM_FIRMWARE_VERSION; + } - if (hardwareVersion != NULL) { - *hardwareVersion = EMBER_AF_INVALID_HARDWARE_VERSION; - } + if (hardwareVersion != NULL) { + *hardwareVersion = EMBER_AF_INVALID_HARDWARE_VERSION; + } - assert(false); -*/ + assert(false); + */ } /** @brief Ota Page Request Server Policy @@ -1308,7 +1216,7 @@ void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId* currentImageInfo, */ uint8_t emberAfOtaPageRequestServerPolicyCallback(void) { - return EMBER_ZCL_STATUS_SUCCESS; + return EMBER_ZCL_STATUS_SUCCESS; } /** @brief Ota Server Block Size @@ -1316,39 +1224,38 @@ uint8_t emberAfOtaPageRequestServerPolicyCallback(void) * This function provides a way for the server to adjust the block size of its * response to an Image block request by a client. * - * @param clientNodeId The node Id of OTA client making an image block request. + * @param clientNodeId The node Id of OTA client making an image block request. * Ver.: always */ uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId) { - // This function provides a way for the server to potentially - // adjust the block size based on the client who is requesting. - // In other words if we are using source routing we will limit - // data returned by enough to put a source route into the message. + // This function provides a way for the server to potentially + // adjust the block size based on the client who is requesting. + // In other words if we are using source routing we will limit + // data returned by enough to put a source route into the message. - // Image Block Response Message Format - // Status Code: 1-byte - // Manuf Code: 2-bytes - // Image Type: 2-bytes - // File Ver: 4-bytes - // File Offset: 4-bytes - // Data Size: 1-byte - // Data: variable - const uint8_t IMAGE_BLOCK_RESPONSE_OVERHEAD = (EMBER_AF_ZCL_OVERHEAD + 14); + // Image Block Response Message Format + // Status Code: 1-byte + // Manuf Code: 2-bytes + // Image Type: 2-bytes + // File Ver: 4-bytes + // File Offset: 4-bytes + // Data Size: 1-byte + // Data: variable + const uint8_t IMAGE_BLOCK_RESPONSE_OVERHEAD = (EMBER_AF_ZCL_OVERHEAD + 14); - EmberApsFrame apsFrame; - uint8_t maxSize; - apsFrame.options = EMBER_APS_OPTION_NONE; + EmberApsFrame apsFrame; + uint8_t maxSize; + apsFrame.options = EMBER_APS_OPTION_NONE; - if (emberAfIsCurrentSecurityProfileSmartEnergy()) { - apsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; - } + if (emberAfIsCurrentSecurityProfileSmartEnergy()) + { + apsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } - maxSize = emberAfMaximumApsPayloadLength(EMBER_OUTGOING_DIRECT, - clientNodeId, - &apsFrame); - maxSize -= IMAGE_BLOCK_RESPONSE_OVERHEAD; - return maxSize; + maxSize = emberAfMaximumApsPayloadLength(EMBER_OUTGOING_DIRECT, clientNodeId, &apsFrame); + maxSize -= IMAGE_BLOCK_RESPONSE_OVERHEAD; + return maxSize; } /** @brief Ota Server Incoming Message Raw @@ -1360,9 +1267,9 @@ uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId) * @param message A pointer to the structure containing the message buffer and * other information about it. Ver.: always */ -bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message) +bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand * message) { - return false; + return false; } /** @brief Ota Server Query @@ -1380,15 +1287,14 @@ bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message) * @param nextUpgradeImageId This is a pointer to a data structure containing * the 'next' software version for the client to download. Ver.: always */ -uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, - uint16_t* hardwareVersion, - EmberAfOtaImageId* nextUpgradeImageId) +uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId * currentImageId, uint16_t * hardwareVersion, + EmberAfOtaImageId * nextUpgradeImageId) { - // If a new software image is available, this function should return EMBER_ZCL_STATUS_SUCCESS - // and populate the 'nextUpgradeImageId' structure with the appropriate values. - // If no new software image is available (i.e. the client should not download a firmware image) - // then the server should return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE. - return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE; + // If a new software image is available, this function should return EMBER_ZCL_STATUS_SUCCESS + // and populate the 'nextUpgradeImageId' structure with the appropriate values. + // If no new software image is available (i.e. the client should not download a firmware image) + // then the server should return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE. + return EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE; } /** @brief Ota Server Send Image Notify @@ -1401,7 +1307,7 @@ uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, * @param endpoint The destination endpoint of the image notify message. May be * a broadcast endpoint. Ver.: always * @param payloadType The type of data the image notify message will contain. 0 - * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. + * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. * 3 = Manufacturer ID, image type ID, and firmware version. Ver.: always * @param queryJitter The percentage of nodes that should respond to this * message, from 1-100. On receipt of this message, each recipient will @@ -1411,13 +1317,10 @@ uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, * within this struct that will be appended to the message is determined by the * previous 'payloadType' argument. Ver.: always */ -bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, - uint8_t endpoint, - uint8_t payloadType, - uint8_t queryJitter, - const EmberAfOtaImageId* id) +bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, uint8_t endpoint, uint8_t payloadType, uint8_t queryJitter, + const EmberAfOtaImageId * id) { - return false; + return false; } /** @brief Ota Server Upgrade End Request @@ -1426,7 +1329,7 @@ bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, * request. If the request indicated a successful download by the client, the * server must tell the client when and if to upgrade to the downloaded image. * - * @param source The node ID of the device that sent the upgrade end request. + * @param source The node ID of the device that sent the upgrade end request. * Ver.: always * @param status This is the ZCL status sent by the client indicating the result * of its attempt to download the new upgrade image. If the status is not @@ -1438,23 +1341,21 @@ bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, * @param imageId This variable indicates the software version that the client * successfully downloaded and is asking to upgrade to. Ver.: always */ -bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, - uint8_t status, - uint32_t* returnValue, - const EmberAfOtaImageId* imageId) -{ - // If the status value is not EMBER_ZCL_STATUS_SUCCESS, then this callback is - // merely informative and no response message will be generated by the server. - // If the server wants the client to NOT apply the upgrade, then it should - // return false. - // If the server wants the client to apply the upgrade, it should return true - // and set the 'returnValue' parameter to when it wants the client to - // apply the upgrade. There are three possible values: - // 0 = Apply the upgrade now - // 0xFFFFFFFF = Don't apply yet, ask again later. - // (anything-else) = Apply the upgrade X minutes from now. - *returnValue = 0; - return true; +bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, uint8_t status, uint32_t * returnValue, + const EmberAfOtaImageId * imageId) +{ + // If the status value is not EMBER_ZCL_STATUS_SUCCESS, then this callback is + // merely informative and no response message will be generated by the server. + // If the server wants the client to NOT apply the upgrade, then it should + // return false. + // If the server wants the client to apply the upgrade, it should return true + // and set the 'returnValue' parameter to when it wants the client to + // apply the upgrade. There are three possible values: + // 0 = Apply the upgrade now + // 0xFFFFFFFF = Don't apply yet, ask again later. + // (anything-else) = Apply the upgrade X minutes from now. + *returnValue = 0; + return true; } /** @brief Ota Storage Check Temp Data @@ -1478,12 +1379,11 @@ bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, * @param newFileInfo This is the image id of the temporary file data stored in * the storage device. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t* currentOffset, - uint32_t* totalImageSize, - EmberAfOtaImageId* newFileInfo) +EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t * currentOffset, uint32_t * totalImageSize, + EmberAfOtaImageId * newFileInfo) { - // If the image data cannot be successfully verified, an error should be returned. - return EMBER_AF_OTA_STORAGE_ERROR; + // If the image data cannot be successfully verified, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Clear Temp Data @@ -1494,8 +1394,8 @@ EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t* current */ EmberAfOtaStorageStatus emberAfOtaStorageClearTempDataCallback(void) { - // If the image data cannot be stored, an error should be returned. - return EMBER_AF_OTA_STORAGE_ERROR; + // If the image data cannot be stored, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Close @@ -1505,8 +1405,8 @@ EmberAfOtaStorageStatus emberAfOtaStorageClearTempDataCallback(void) */ void emberAfOtaStorageCloseCallback(void) { - // Please implement me. - assert(false); + // Please implement me. + assert(false); } /** @brief Ota Storage Driver Download Finish @@ -1519,9 +1419,9 @@ void emberAfOtaStorageCloseCallback(void) */ void emberAfOtaStorageDriverDownloadFinishCallback(uint32_t offset) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); } /** @brief Ota Storage Driver Init @@ -1531,10 +1431,10 @@ void emberAfOtaStorageDriverDownloadFinishCallback(uint32_t offset) */ bool emberAfOtaStorageDriverInitCallback(void) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); - return false; + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; } /** @brief Ota Storage Driver Invalidate Image @@ -1546,10 +1446,10 @@ bool emberAfOtaStorageDriverInitCallback(void) */ EmberAfOtaStorageStatus emberAfOtaStorageDriverInvalidateImageCallback(void) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); - return EMBER_AF_OTA_STORAGE_ERROR; + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Driver Prepare To Resume Download @@ -1561,8 +1461,8 @@ EmberAfOtaStorageStatus emberAfOtaStorageDriverInvalidateImageCallback(void) */ EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(void) { - assert(false); - return EMBER_AF_OTA_STORAGE_ERROR; + assert(false); + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Driver Read @@ -1572,19 +1472,17 @@ EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(v * * @param offset The address offset from the start of the storage device where * data is to be read. Ver.: always - * @param length The length of the data to be read from the storage device. + * @param length The length of the data to be read from the storage device. * Ver.: always * @param returnData A pointer where the data read from the device should be * written to. Ver.: always */ -bool emberAfOtaStorageDriverReadCallback(uint32_t offset, - uint32_t length, - uint8_t* returnData) +bool emberAfOtaStorageDriverReadCallback(uint32_t offset, uint32_t length, uint8_t * returnData) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); - return false; + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; } /** @brief Ota Storage Driver Retrieve Last Stored Offset @@ -1596,10 +1494,10 @@ bool emberAfOtaStorageDriverReadCallback(uint32_t offset, */ uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); - return 0; + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return 0; } /** @brief Ota Storage Driver Write @@ -1611,29 +1509,27 @@ uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void) * device. Ver.: always * @param offset The address offset from the start of the storage device where * data will be written. Ver.: always - * @param length The length of the data to be written to the storage device. + * @param length The length of the data to be written to the storage device. * Ver.: always */ -bool emberAfOtaStorageDriverWriteCallback(const uint8_t* dataToWrite, - uint32_t offset, - uint32_t length) +bool emberAfOtaStorageDriverWriteCallback(const uint8_t * dataToWrite, uint32_t offset, uint32_t length) { - // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. - // Please implement me. - assert(false); - return false; + // The storage driver and the rest of the OTA bootload code will not function correctly unless it is implemnted. + // Please implement me. + assert(false); + return false; } /** @brief Ota Storage Finish Download * * This function indicates to the storage module that the download has finished. * - * @param offset The final offset of the downloaded file (i.e. the total size) + * @param offset The final offset of the downloaded file (i.e. the total size) * Ver.: always */ EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset) { - return EMBER_AF_OTA_STORAGE_SUCCESS; + return EMBER_AF_OTA_STORAGE_SUCCESS; } /** @brief Ota Storage Get Count @@ -1644,7 +1540,7 @@ EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset) */ uint8_t emberAfOtaStorageGetCountCallback(void) { - return 0; + return 0; } /** @brief Ota Storage Get Full Header @@ -1657,11 +1553,10 @@ uint8_t emberAfOtaStorageGetCountCallback(void) * @param returnData This is a pointer to the location of the structure that * will be populated with data. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId* id, - EmberAfOtaHeader* returnData) +EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId * id, EmberAfOtaHeader * returnData) { - // If the requested image cannot be found, then an error shouldb e returned. - return EMBER_AF_OTA_STORAGE_ERROR; + // If the requested image cannot be found, then an error shouldb e returned. + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Get Total Image Size @@ -1672,10 +1567,10 @@ EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaI * @param id A pointer to the image identifier for the OTA file to retrieve * information for. Ver.: always */ -uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId* id) +uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId * id) { - // On failure this should return an image size of zero. - return 0; + // On failure this should return an image size of zero. + return 0; } /** @brief Ota Storage Init @@ -1685,7 +1580,7 @@ uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId* id) */ EmberAfOtaStorageStatus emberAfOtaStorageInitCallback(void) { - return EMBER_AF_OTA_STORAGE_SUCCESS; + return EMBER_AF_OTA_STORAGE_SUCCESS; } /** @brief Ota Storage Iterator First @@ -1697,10 +1592,11 @@ EmberAfOtaStorageStatus emberAfOtaStorageInitCallback(void) */ EmberAfOtaImageId emberAfOtaStorageIteratorFirstCallback(void) { - // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will manipulate. + // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will + // manipulate. - // If there are no images at all, this function should return the invalid image id. - return emberAfInvalidImageId; + // If there are no images at all, this function should return the invalid image id. + return emberAfInvalidImageId; } /** @brief Ota Storage Iterator Next @@ -1712,10 +1608,11 @@ EmberAfOtaImageId emberAfOtaStorageIteratorFirstCallback(void) */ EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void) { - // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will manipulate. + // It is expected that the storage module maintain its own internal iterator that the 'first' and 'next' functions will + // manipulate. - // If there are no more images, this function should return the invalid image id. - return emberAfInvalidImageId; + // If there are no more images, this function should return the invalid image id. + return emberAfInvalidImageId; } /** @brief Ota Storage Read Image Data @@ -1734,14 +1631,11 @@ EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void) * of data read will be written to. A short read may occur if the end of file * was reached. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId* id, - uint32_t offset, - uint32_t length, - uint8_t* returnData, - uint32_t* returnedLength) +EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId * id, uint32_t offset, uint32_t length, + uint8_t * returnData, uint32_t * returnedLength) { - // If the requested image cannot be found, then an error should be returned. - return EMBER_AF_OTA_STORAGE_ERROR; + // If the requested image cannot be found, then an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Ota Storage Search @@ -1762,12 +1656,10 @@ EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaI * version is present in an OTA file but the other parameters match, the file * will be considered a match Ver.: always */ -EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, - uint16_t imageTypeId, - const uint16_t* hardwareVersion) +EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, uint16_t imageTypeId, const uint16_t * hardwareVersion) { - // If no image is found that matches the search criteria, this function should return the invalid image id. - return emberAfInvalidImageId; + // If no image is found that matches the search criteria, this function should return the invalid image id. + return emberAfInvalidImageId; } /** @brief Ota Storage Write Temp Data @@ -1781,12 +1673,10 @@ EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, * @param data A pointer to the temporary data that will be written to the * storage device. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, - uint32_t length, - const uint8_t* data) +EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, uint32_t length, const uint8_t * data) { - // If the image data cannot be stored, an error should be returned. - return EMBER_AF_OTA_STORAGE_ERROR; + // If the image data cannot be stored, an error should be returned. + return EMBER_AF_OTA_STORAGE_ERROR; } /** @brief Outgoing Packet Filter @@ -1802,7 +1692,7 @@ EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, * If the stack receives an 802.15.4 MAC beacon, it will call this function with * the packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. - + * The implementation of this callback may alter the data contained in * packetData, modify options and flags in the auxillary data, or consume the * packet itself, either sending the message, or discarding it as it sees fit. @@ -1814,12 +1704,10 @@ EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, * @param size_p a pointer containing the size value of the packet Ver.: always * @param data auxillary data included with the packet Ver.: always */ -EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, - uint8_t* packetData, - uint8_t* size_p, - void* data) +EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data) { - return EMBER_ACCEPT_PACKET; + return EMBER_ACCEPT_PACKET; } /** @brief Partner Link Key Exchange Request @@ -1834,7 +1722,7 @@ EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType pack */ EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner) { - return EMBER_ZDP_NOT_SUPPORTED; + return EMBER_ZDP_NOT_SUPPORTED; } /** @brief Partner Link Key Exchange Response @@ -1848,10 +1736,7 @@ EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner) * @param sender The EUI of the remote node. Ver.: always * @param status The ZDO response status. Ver.: always */ -void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, - EmberZdoStatus status) -{ -} +void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, EmberZdoStatus status) {} /** @brief Performing Key Establishment * @@ -1862,7 +1747,7 @@ void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, */ bool emberAfPerformingKeyEstablishmentCallback(void) { - return false; + return false; } /** @brief Get Distributed Key @@ -1877,7 +1762,7 @@ bool emberAfPerformingKeyEstablishmentCallback(void) */ bool emberAfPluginNetworkSteeringGetDistributedKeyCallback(EmberKeyData * key) { - return false; + return false; } /** @brief Get Node Type @@ -1892,9 +1777,7 @@ bool emberAfPluginNetworkSteeringGetDistributedKeyCallback(EmberKeyData * key) */ EmberNodeType emberAfPluginNetworkSteeringGetNodeTypeCallback(EmberAfPluginNetworkSteeringJoiningState state) { - return ((emAfCurrentZigbeeProNetwork->nodeType == EMBER_COORDINATOR) - ? EMBER_ROUTER - : emAfCurrentZigbeeProNetwork->nodeType); + return ((emAfCurrentZigbeeProNetwork->nodeType == EMBER_COORDINATOR) ? EMBER_ROUTER : emAfCurrentZigbeeProNetwork->nodeType); } /** @brief Get Power For Radio Channel @@ -1908,7 +1791,7 @@ EmberNodeType emberAfPluginNetworkSteeringGetNodeTypeCallback(EmberAfPluginNetwo */ int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t channel) { - return emberAfMaxPowerLevel(); + return emberAfMaxPowerLevel(); } /** @brief Post Attribute Change @@ -1926,16 +1809,9 @@ int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t chann * @param size Ver.: always * @param value Ver.: always */ -void emberAfPostAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t type, - uint8_t size, - uint8_t* value) -{ -} +void emberAfPostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) +{} /** @brief Post Em4 Reset * @@ -1944,7 +1820,7 @@ void emberAfPostAttributeChangeCallback(uint8_t endpoint, */ void emberAfPostEm4ResetCallback(void) { - return; + return; } /** @brief Pre Attribute Change @@ -1964,16 +1840,11 @@ void emberAfPostEm4ResetCallback(void) * @param size Ver.: always * @param value Ver.: always */ -EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t type, - uint8_t size, - uint8_t* value) +EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, + uint8_t * value) { - return EMBER_ZCL_STATUS_SUCCESS; + return EMBER_ZCL_STATUS_SUCCESS; } /** @brief Pre Cli Send @@ -1982,7 +1853,7 @@ EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, * constructed over CLI to the stack primitives for sending. If the function * returns true it is assumed that the callback has consumed and processed the * message. The framework will not do any further processing on the message. - + * If the function returns false then it is assumed that the callback has * not processed the message and the framework will continue to process * accordingly. @@ -1993,13 +1864,10 @@ EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, * @param message Pointer to the message payload Ver.: always * @param messageLength Length of the message payload Ver.: always */ -bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, - EmberNodeId source, - EmberNodeId destination, - uint8_t* message, +bool emberAfPreCliSendCallback(EmberApsFrame * apsFrame, EmberNodeId source, EmberNodeId destination, uint8_t * message, uint16_t messageLength) { - return false; + return false; } /** @brief Pre Command Received @@ -2015,9 +1883,9 @@ bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, * * @param cmd Ver.: always */ -bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd) +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd) { - return false; + return false; } /** @brief Pre Message Received @@ -2027,8 +1895,8 @@ bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd) * over the air but has not yet been parsed by the ZCL command-handling code. If * you wish to parse some messages that are completely outside the ZCL * specification or are not handled by the Application Framework's command - * handling code, you should intercept them for parsing in this callback. - + * handling code, you should intercept them for parsing in this callback. + * This callback returns a Boolean value indicating whether or not the message * has been handled. If the callback returns a value of true, then the * Application Framework assumes that the message has been handled and it does @@ -2043,9 +1911,9 @@ bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd) * * @param incomingMessage Ver.: always */ -bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage) +bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage * incomingMessage) { - return false; + return false; } /** @brief Pre Message Send @@ -2067,10 +1935,9 @@ bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage) * @param status A pointer to the status code value that will be returned to the * caller. Ver.: always */ -bool emberAfPreMessageSendCallback(EmberAfMessageStruct* messageStruct, - EmberStatus* status) +bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status) { - return false; + return false; } /** @brief Pre Ncp Reset @@ -2078,9 +1945,7 @@ bool emberAfPreMessageSendCallback(EmberAfMessageStruct* messageStruct, * This function will be called prior to the reset of the NCP by the host. * */ -void emberAfPreNcpResetCallback(void) -{ -} +void emberAfPreNcpResetCallback(void) {} /** @brief Pre ZDO Message Received * @@ -2094,12 +1959,9 @@ void emberAfPreNcpResetCallback(void) * @param message Ver.: always * @param length Ver.: always */ -bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, - EmberApsFrame* apsFrame, - uint8_t* message, - uint16_t length) +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length) { - return false; + return false; } /** @brief Read Attributes Response @@ -2109,15 +1971,13 @@ bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, * return true if the message was processed or false if it was not. * * @param clusterId The cluster identifier of this response. Ver.: always - * @param buffer Buffer containing the list of read attribute status records. + * @param buffer Buffer containing the list of read attribute status records. * Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen) +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return false; + return false; } /** @brief Read Reporting Configuration Command @@ -2128,9 +1988,9 @@ bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, * * @param cmd Ver.: always */ -bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand *cmd) +bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand * cmd) { - return false; + return false; } /** @brief Read Reporting Configuration Response @@ -2145,11 +2005,9 @@ bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterComman * records. Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen) +bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return false; + return false; } /** @brief Scenes Cluster Recall Saved Scene @@ -2161,11 +2019,9 @@ bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterI * @param groupId The group identifier. Ver.: always * @param sceneId The scene identifier. Ver.: always */ -EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, - uint16_t groupId, - uint8_t sceneId) +EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId) { - return EMBER_ZCL_STATUS_FAILURE; + return EMBER_ZCL_STATUS_FAILURE; } /** @brief Registration Abort @@ -2174,9 +2030,7 @@ EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, * process. * */ -void emberAfRegistrationAbortCallback(void) -{ -} +void emberAfRegistrationAbortCallback(void) {} /** @brief Registration * @@ -2187,9 +2041,7 @@ void emberAfRegistrationAbortCallback(void) * * @param success true if registration succeeded, false otherwise. Ver.: always */ -void emberAfRegistrationCallback(bool success) -{ -} +void emberAfRegistrationCallback(bool success) {} /** @brief Registration Start * @@ -2202,7 +2054,7 @@ void emberAfRegistrationCallback(bool success) */ EmberStatus emberAfRegistrationStartCallback(void) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Remote Delete Binding Permission @@ -2215,7 +2067,7 @@ EmberStatus emberAfRegistrationStartCallback(void) */ EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index) { - return EMBER_SUCCESS; // default + return EMBER_SUCCESS; // default } /** @brief Remote Set Binding Permission @@ -2226,9 +2078,9 @@ EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index) * * @param entry Ember Binding Tablet Entry Ver.: always */ -EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry *entry) +EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry * entry) { - return EMBER_SUCCESS; // default + return EMBER_SUCCESS; // default } /** @brief Remove From Current App Tasks @@ -2243,9 +2095,7 @@ EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEnt * * @param tasks Ver.: always */ -void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks) -{ -} +void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks) {} /** @brief Scenes Cluster Remove Scenes In Group * @@ -2254,10 +2104,7 @@ void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks) * @param endpoint Endpoint Ver.: always * @param groupId Group ID Ver.: always */ -void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, - uint16_t groupId) -{ -} +void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, uint16_t groupId) {} /** @brief Report Attributes * @@ -2270,11 +2117,9 @@ void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, * always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen) +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return false; + return false; } /** @brief Reporting Attribute Change @@ -2292,15 +2137,9 @@ bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, * @param type Ver.: always * @param data Ver.: always */ -void emberAfReportingAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - EmberAfAttributeType type, - uint8_t *data) -{ -} +void emberAfReportingAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, EmberAfAttributeType type, uint8_t * data) +{} /** @brief Scan Error * @@ -2310,14 +2149,12 @@ void emberAfReportingAttributeChangeCallback(uint8_t endpoint, * * @param status The status of the scan. Ver.: always */ -void emberAfScanErrorCallback(EmberStatus status) -{ -} +void emberAfScanErrorCallback(EmberStatus status) {} /** @brief Security Init * * This callback is called by the framework to give the application a chance to - * modify the security settings of the node during network initialization. + * modify the security settings of the node during network initialization. * Depending on the context when this callback is called, the pointer to the * initial security state may be NULL, which means the initial security state * can no longer be modified as the node is already operating on the network. @@ -2326,11 +2163,7 @@ void emberAfScanErrorCallback(EmberStatus status) * @param extended Ver.: always * @param trustCenter Ver.: always */ -void emberAfSecurityInitCallback(EmberInitialSecurityState *state, - EmberExtendedSecurityBitmask *extended, - bool trustCenter) -{ -} +void emberAfSecurityInitCallback(EmberInitialSecurityState * state, EmberExtendedSecurityBitmask * extended, bool trustCenter) {} /** @brief Key Establishment Cluster Server Command Received * @@ -2342,9 +2175,9 @@ void emberAfSecurityInitCallback(EmberInitialSecurityState *state, * * @param cmd Ver.: always */ -bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand *cmd) +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand * cmd) { - return false; + return false; } /** @brief Set Default Poll Control @@ -2354,9 +2187,7 @@ bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterC * * @param control Ver.: always */ -void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control) -{ -} +void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control) {} /** @brief Set Default Sleep Control * @@ -2366,9 +2197,7 @@ void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control) * * @param control Ver.: always */ -void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control) -{ -} +void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control) {} /** @brief Set Form And Join Extended Pan Id * @@ -2379,9 +2208,7 @@ void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control) * * @param extendedPanId Ver.: always */ -void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t *extendedPanId) -{ -} +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t * extendedPanId) {} /** @brief Set Long Poll Interval Ms * @@ -2392,9 +2219,7 @@ void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t *extendedPanId) * * @param longPollIntervalMs Ver.: always */ -void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs) -{ -} +void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs) {} /** @brief Set Long Poll Interval Qs * @@ -2405,9 +2230,7 @@ void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs) * * @param longPollIntervalQs Ver.: always */ -void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs) -{ -} +void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs) {} /** @brief Set Short Poll Interval Ms * @@ -2418,9 +2241,7 @@ void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs) * * @param shortPollIntervalMs Ver.: always */ -void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs) -{ -} +void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs) {} /** @brief Set Short Poll Interval Qs * @@ -2431,9 +2252,7 @@ void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs) * * @param shortPollIntervalQs Ver.: always */ -void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs) -{ -} +void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs) {} /** @brief Set Source Route Overhead * @@ -2444,10 +2263,7 @@ void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs) * @param destination The node id of the destination Ver.: always * @param overhead The overhead in bytes Ver.: always */ -void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, - uint8_t overhead) -{ -} +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, uint8_t overhead) {} /** @brief Set Time * @@ -2460,9 +2276,7 @@ void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, * * @param utcTime Ver.: always */ -void emberAfSetTimeCallback(uint32_t utcTime) -{ -} +void emberAfSetTimeCallback(uint32_t utcTime) {} /** @brief On/off Cluster Set Value * @@ -2473,11 +2287,9 @@ void emberAfSetTimeCallback(uint32_t utcTime) * @param command Ver.: always * @param initiatedByLevelChange Ver.: always */ -EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, - uint8_t command, - bool initiatedByLevelChange) +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange) { - return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; } /** @brief Set Wake Timeout Bitmask @@ -2489,9 +2301,7 @@ EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, * * @param tasks Ver.: always */ -void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks) -{ -} +void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks) {} /** @brief Set Wake Timeout Ms * @@ -2502,9 +2312,7 @@ void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks) * * @param wakeTimeoutMs Ver.: always */ -void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs) -{ -} +void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs) {} /** @brief Set Wake Timeout Qs * @@ -2515,9 +2323,7 @@ void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs) * * @param wakeTimeoutQs Ver.: always */ -void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs) -{ -} +void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs) {} /** @brief Start Move * @@ -2527,7 +2333,7 @@ void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs) */ bool emberAfStartMoveCallback(void) { - return false; + return false; } /** @brief Start Search For Joinable Network @@ -2539,7 +2345,7 @@ bool emberAfStartMoveCallback(void) */ EmberStatus emberAfStartSearchForJoinableNetworkCallback(void) { - return EMBER_LIBRARY_NOT_PRESENT; + return EMBER_LIBRARY_NOT_PRESENT; } /** @brief Stop Move @@ -2548,9 +2354,7 @@ EmberStatus emberAfStartSearchForJoinableNetworkCallback(void) * new parent. * */ -void emberAfStopMoveCallback(void) -{ -} +void emberAfStopMoveCallback(void) {} /** @brief Scenes Cluster Store Current Scene * @@ -2564,11 +2368,9 @@ void emberAfStopMoveCallback(void) * @param groupId The group identifier. Ver.: always * @param sceneId The scene identifier. Ver.: always */ -EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, - uint16_t groupId, - uint8_t sceneId) +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId) { - return EMBER_ZCL_STATUS_FAILURE; + return EMBER_ZCL_STATUS_FAILURE; } /** @brief Trust Center Join @@ -2585,13 +2387,9 @@ EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, * @param status Ver.: always * @param decision Ver.: always */ -void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, - EmberEUI64 newNodeEui64, - EmberNodeId parentOfNewNode, - EmberDeviceUpdate status, - EmberJoinDecision decision) -{ -} +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, EmberEUI64 newNodeEui64, EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, EmberJoinDecision decision) +{} /** @brief Trust Center Keepalive Abort * @@ -2599,9 +2397,7 @@ void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, * keepalive process. * */ -void emberAfTrustCenterKeepaliveAbortCallback(void) -{ -} +void emberAfTrustCenterKeepaliveAbortCallback(void) {} /** @brief Trust Center Keepalive Update * @@ -2613,9 +2409,7 @@ void emberAfTrustCenterKeepaliveAbortCallback(void) * * @param registrationComplete Ver.: always */ -void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete) -{ -} +void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete) {} /** @brief Unused Pan Id Found * @@ -2627,10 +2421,7 @@ void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete) * @param panId Ver.: always * @param channel Ver.: always */ -void emberAfUnusedPanIdFoundCallback(EmberPanId panId, - uint8_t channel) -{ -} +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, uint8_t channel) {} /** @brief Write Attributes Response * @@ -2639,15 +2430,13 @@ void emberAfUnusedPanIdFoundCallback(EmberPanId panId, * return true if the message was processed or false if it was not. * * @param clusterId The cluster identifier of this response. Ver.: always - * @param buffer Buffer containing the list of write attribute status records. + * @param buffer Buffer containing the list of write attribute status records. * Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen) +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return false; + return false; } /** @brief Zigbee Key Establishment @@ -2659,25 +2448,17 @@ bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, * if the Key establishment failed. Ver.: always * @param status The status of the key establishment. Ver.: always */ -void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, - EmberKeyStatus status) -{ -} +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status) {} /** * @brief Called whenever the radio is powered off. */ -void halRadioPowerDownHandler(void) -{ -} - +void halRadioPowerDownHandler(void) {} /** * @brief Called whenever the radio is powered on. */ -void halRadioPowerUpHandler(void) -{ -} +void halRadioPowerUpHandler(void) {} /** * @brief Called whenever the microcontroller enters/exits a idle/sleep mode @@ -2685,6 +2466,4 @@ void halRadioPowerUpHandler(void) * @param enter True if entering idle/sleep, False if exiting * @param sleepMode Idle/sleep mode */ -void halSleepCallback(boolean enter, SleepModes sleepMode) -{ -} +void halSleepCallback(boolean enter, SleepModes sleepMode) {} diff --git a/examples/wifi-echo/server/esp32/main/gen/callback.h b/examples/wifi-echo/server/esp32/main/gen/callback.h index dcbd4f35d7fecb..61b29baad88c7a 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback.h +++ b/examples/wifi-echo/server/esp32/main/gen/callback.h @@ -39,7 +39,6 @@ #ifndef SILABS_EMBER_AF_CALLBACK_PROTOTYPES #define SILABS_EMBER_AF_CALLBACK_PROTOTYPES - /** * @addtogroup callback Application Framework callback interface Reference * This header provides callback function prototypes to interface the @@ -47,14 +46,10 @@ * @{ */ - #include "../af-types.h" //#include "hal/hal.h" //#include EMBER_AF_API_NETWORK_STEERING - - - /** @name Non-Cluster Related Callbacks */ // @{ /** @brief Add To Current App Tasks @@ -102,13 +97,9 @@ void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks); * @param value Ver.: always * @param type Ver.: always */ -EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t* value, - uint8_t type); +EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t * value, uint8_t type); /** @brief Attribute Read Access * * This function is called whenever the Application Framework needs to check @@ -119,9 +110,7 @@ EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_ * @param manufacturerCode Ver.: always * @param attributeId Ver.: always */ -bool emberAfAttributeReadAccessCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint16_t manufacturerCode, +bool emberAfAttributeReadAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, uint16_t attributeId); /** @brief Attribute Write Access * @@ -133,9 +122,7 @@ bool emberAfAttributeReadAccessCallback(uint8_t endpoint, * @param manufacturerCode Ver.: always * @param attributeId Ver.: always */ -bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - uint16_t manufacturerCode, +bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, uint16_t attributeId); /** @brief Clear Report Table * @@ -153,8 +140,7 @@ EmberStatus emberAfClearReportTableCallback(void); * @param endpoint Ver.: always * @param clusterId Ver.: always */ -void emberAfClusterInitCallback(uint8_t endpoint, - EmberAfClusterId clusterId); +void emberAfClusterInitCallback(uint8_t endpoint, EmberAfClusterId clusterId); /** @brief Cluster Security Custom * * This callback is fired when determining if APS encryption is required for a @@ -168,10 +154,7 @@ void emberAfClusterInitCallback(uint8_t endpoint, * always * @param commandId The ZCL command ID being sent/received. Ver.: always */ -bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, - EmberAfClusterId clusterId, - bool incoming, - uint8_t commandId); +bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, EmberAfClusterId clusterId, bool incoming, uint8_t commandId); /** @brief Configure Reporting Command * * This function is called by the application framework when a Configure @@ -182,7 +165,7 @@ bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, * * @param cmd Ver.: always */ -bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd); +bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand * cmd); /** @brief Configure Reporting Response * * This function is called by the application framework when a Configure @@ -195,9 +178,7 @@ bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand *cmd); * always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen); +bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); /** @brief Default Response * * This function is called by the application framework when a Default Response @@ -210,9 +191,7 @@ bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, * @param status Specifies either SUCCESS or the nature of the error that was * detected in the received command. Ver.: always */ -bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, - uint8_t commandId, - EmberAfStatus status); +bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, uint8_t commandId, EmberAfStatus status); /** @brief Discover Attributes Response * * This function is called by the application framework when a Discover @@ -233,11 +212,8 @@ bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, * @param extended Indicates whether the response is in the extended format or * not. Ver.: always */ -bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, - bool discoveryComplete, - uint8_t *buffer, - uint16_t bufLen, - bool extended); +bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, bool discoveryComplete, uint8_t * buffer, + uint16_t bufLen, bool extended); /** @brief Discover Commands Generated Response * * This function is called by the framework when Discover Commands Generated @@ -252,11 +228,8 @@ bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, * @param commandIdCount The length of bytes of the list, whish is the same as * the number of identifiers. Ver.: always */ -bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, - uint16_t manufacturerCode, - bool discoveryComplete, - uint8_t *commandIds, - uint16_t commandIdCount); +bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount); /** @brief Discover Commands Received Response * * This function is called by the framework when Discover Commands Received @@ -271,11 +244,8 @@ bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId * @param commandIdCount The length of bytes of the list, whish is the same as * the number of identifiers. Ver.: always */ -bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, - uint16_t manufacturerCode, - bool discoveryComplete, - uint8_t *commandIds, - uint16_t commandIdCount); +bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount); /** @brief Eeprom Init * * Tells the system to initialize the EEPROM if it is not already initialized. @@ -306,8 +276,7 @@ void emberAfEepromShutdownCallback(void); * @param rssi The receive signal strength indicator for the channel. Ver.: * always */ -void emberAfEnergyScanResultCallback(uint8_t channel, - int8_t rssi); +void emberAfEnergyScanResultCallback(uint8_t channel, int8_t rssi); /** @brief External Attribute Read * * Like emberAfExternalAttributeWriteCallback above, this function is called @@ -344,12 +313,9 @@ void emberAfEnergyScanResultCallback(uint8_t channel, * @param buffer Ver.: always * @param maxReadLength Ver.: always */ -EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *attributeMetadata, - uint16_t manufacturerCode, - uint8_t *buffer, - uint16_t maxReadLength); +EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer, uint16_t maxReadLength); /** @brief External Attribute Write * * This function is called whenever the Application Framework needs to write an @@ -396,11 +362,9 @@ EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, * @param manufacturerCode Ver.: always * @param buffer Ver.: always */ -EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeMetadata *attributeMetadata, - uint16_t manufacturerCode, - uint8_t *buffer); +EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer); /** @brief Find Unused Pan Id And Form * * This function is called by the framework to search for an unused PAN id and @@ -486,7 +450,7 @@ EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void); * Get the endpoint number based on the passed index. By default the framework * handles this by managing endpoints based on the precompiled configuration * defined in AppBuilder. This callback can override this behavior at runtime - * and provide additional endpoints or different data than the compiled values. + * and provide additional endpoints or different data than the compiled values. * If the index is overridden than the callback shall return true and set the * endpointReturn parameter accordingly. A value of 0xFF means the endpoint * doesn't exist at that index. @@ -497,8 +461,7 @@ EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void); * @param index The index of the endpoint. Ver.: always * @param endpointReturn The value of endpoint. Ver.: always */ -bool emberAfGetEndpointByIndexCallback(uint8_t index, - uint8_t* endpointReturn); +bool emberAfGetEndpointByIndexCallback(uint8_t index, uint8_t * endpointReturn); /** @brief Get Endpoint Description * * This callback is called by the framework whenever it receives a ZDO request @@ -515,8 +478,7 @@ bool emberAfGetEndpointByIndexCallback(uint8_t index, * information is written if the callback is providing the information. Ver.: * always */ -bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, - EmberEndpointDescription* result); +bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, EmberEndpointDescription * result); /** @brief Get Endpoint Info * * This function is a callback to an application implemented endpoint that @@ -534,9 +496,7 @@ bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, * @param returnEndpointInfo A pointer to a data struct that will be written * with information about the endpoint. Ver.: always */ -bool emberAfGetEndpointInfoCallback(uint8_t endpoint, - uint8_t* returnNetworkIndex, - EmberAfEndpointInfoStruct* returnEndpointInfo); +bool emberAfGetEndpointInfoCallback(uint8_t endpoint, uint8_t * returnNetworkIndex, EmberAfEndpointInfoStruct * returnEndpointInfo); /** @brief Get Form And Join Extended Pan Id * * This callback is called by the framework to get the extended PAN ID used by @@ -546,7 +506,7 @@ bool emberAfGetEndpointInfoCallback(uint8_t endpoint, * * @param resultLocation Ver.: always */ -void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t *resultLocation); +void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t * resultLocation); /** @brief Get Long Poll Interval Ms * * This function is only useful to end devices. This function will return the @@ -568,7 +528,7 @@ uint32_t emberAfGetLongPollIntervalQsCallback(void); /** @brief Get Short Poll Interval Ms * * This function is only useful to sleepy end devices. This function will - * return the short poll interval (in milliseconds) for the current network. + * return the short poll interval (in milliseconds) for the current network. * This interval is the maximum amount of time a child will wait between polls * of its parent when it is expecting data. * @@ -577,7 +537,7 @@ uint16_t emberAfGetShortPollIntervalMsCallback(void); /** @brief Get Short Poll Interval Qs * * This function is only useful to sleepy end devices. This function will - * return the short poll interval (in quarter seconds) for the current network. + * return the short poll interval (in quarter seconds) for the current network. * This interval is the maximum amount of time a child will wait between polls * of its parent when it is expecting data. * @@ -629,8 +589,7 @@ uint16_t emberAfGetWakeTimeoutQsCallback(void); * either ::BUTTON_PRESSED if the button has been pressed or ::BUTTON_RELEASED * if the button has been released. Ver.: always */ -void emberAfHalButtonIsrCallback(uint8_t button, - uint8_t state); +void emberAfHalButtonIsrCallback(uint8_t button, uint8_t state); /** @brief Incoming Packet Filter * * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** @@ -656,10 +615,8 @@ void emberAfHalButtonIsrCallback(uint8_t button, * @param size_p a pointer containing the size value of the packet Ver.: always * @param data auxillary data included with the packet Ver.: always */ -EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, - uint8_t* packetData, - uint8_t* size_p, - void* data); +EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data); /** @brief Initiate Inter Pan Key Establishment * * This function is called by the framework to initiate key establishment with a @@ -671,8 +628,7 @@ EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType pack * @param panId The PAN id of the remote device. Ver.: always * @param eui64 The EUI64 of the remote device. Ver.: always */ -EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, - const EmberEUI64 eui64); +EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, const EmberEUI64 eui64); /** @brief Initiate Key Establishment * * This function is called by the framework to initiate key establishment with a @@ -683,8 +639,7 @@ EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, * @param nodeId The node id of the remote device. Ver.: always * @param endpoint The endpoint on the remote device. Ver.: always */ -EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, - uint8_t endpoint); +EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, uint8_t endpoint); /** @brief Initiate Partner Link Key Exchange * * This function is called by the framework to initiate a partner link key @@ -699,12 +654,11 @@ EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, * @param callback The callback that should be called when the partner link key * exchange completse. Ver.: always */ -EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, - uint8_t endpoint, - EmberAfPartnerLinkKeyExchangeCallback *callback); +EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback * callback); /** @brief Inter Pan Key Establishment * - * A callback by the key-establishment code to indicate an event has occurred. + * A callback by the key-establishment code to indicate an event has occurred. * For error codes this is purely a notification. For non-error status codes * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or * disallow the operation. If the application returns true then the key @@ -717,11 +671,8 @@ EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, * @param eui64 Ver.: always * @param delayInSeconds Ver.: always */ -bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, - bool amInitiator, - EmberPanId panId, - const EmberEUI64 eui64, - uint8_t delayInSeconds); +bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberPanId panId, + const EmberEUI64 eui64, uint8_t delayInSeconds); /** @brief Interpan Send Message * * This function will send a raw MAC message with interpan frame format using @@ -732,12 +683,10 @@ bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessag * always * @param message The message data received or to send. Ver.: always */ -EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, - uint16_t messageLength, - uint8_t* message); +EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message); /** @brief Key Establishment * - * A callback by the key-establishment code to indicate an event has occurred. + * A callback by the key-establishment code to indicate an event has occurred. * For error codes this is purely a notification. For non-error status codes * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or * disallow the operation. If the application returns true then the key @@ -749,9 +698,7 @@ EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader* header, * @param partnerShortId Ver.: always * @param delayInSeconds Ver.: always */ -bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, - bool amInitiator, - EmberNodeId partnerShortId, +bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberNodeId partnerShortId, uint8_t delayInSeconds); /** @brief Main Init * @@ -789,9 +736,7 @@ void emberAfMainInitCallback(void); * @param argc Ver.: always * @param argv Ver.: always */ -bool emberAfMainStartCallback(int* returnCode, - int argc, - char** argv); +bool emberAfMainStartCallback(int * returnCode, int argc, char ** argv); /** @brief Main Tick * * Whenever main application tick is called, this callback will be called at the @@ -824,12 +769,8 @@ void emberAfMarkBuffersCallback(void); * @param message Ver.: always * @param status Ver.: always */ -bool emberAfMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame* apsFrame, - uint16_t msgLen, - uint8_t* message, - EmberStatus status); +bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ncp Init * * This function is called when the network coprocessor is being initialized, @@ -858,15 +799,13 @@ void emberAfNcpIsAwakeIsrCallback(void); * * This callback is generated when an active scan finds a 802.15.4 network. * - * @param networkFound A struct containing information about the network found. + * @param networkFound A struct containing information about the network found. * Ver.: always * @param lqi The link quality indication of the network found. Ver.: always - * @param rssi The received signal strength indication of the network found. + * @param rssi The received signal strength indication of the network found. * Ver.: always */ -void emberAfNetworkFoundCallback(EmberZigbeeNetwork* networkFound, - uint8_t lqi, - int8_t rssi); +void emberAfNetworkFoundCallback(EmberZigbeeNetwork * networkFound, uint8_t lqi, int8_t rssi); /** @brief Network Key Update Complete * * This is called by the framework when a network key update operation started @@ -885,8 +824,7 @@ void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status); * @param ncpUpgradeTagId The tag ID of the upgrade data that will be used to * bootload the device. Ver.: always */ -uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, - uint16_t ncpUpgradeTagId); +uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId * id, uint16_t ncpUpgradeTagId); /** @brief Ota Client Bootload * * This callback is fired when the OTA Client recevies a command to bootload the @@ -896,7 +834,7 @@ uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId* id, * @param id This is the identifier relating to the image that has been * downloaded and is ready for bootload. Ver.: always */ -void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id); +void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId * id); /** @brief Ota Client Custom Verify * * This callback is executed by the OTA client after the signature verification @@ -907,8 +845,7 @@ void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId* id); * started. Ver.: always * @param id This is ID of the image to be verified. Ver.: always */ -EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, - const EmberAfOtaImageId* id); +EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, const EmberAfOtaImageId * id); /** @brief Ota Client Download Complete * * This callback indicates that the OTA client has completed the download of a @@ -924,8 +861,7 @@ EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerificati * @param id This is the image identifier information that corresponds to the * download result. Ver.: always */ -bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, - const EmberAfOtaImageId* id); +bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, const EmberAfOtaImageId * id); /** @brief Ota Client Incoming Message Raw * * This callback is for processing incoming messages for the Over-the-air @@ -935,7 +871,7 @@ bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, * @param message A pointer to the structure containing the message buffer and * other information about it. Ver.: always */ -bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand *message); +bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand * message); /** @brief Ota Client Start * * This callback should be called when the profile specific registration has @@ -960,8 +896,7 @@ void emberAfOtaClientStartCallback(void); * the query. If no hardware version should be used, then * EMBER_AF_INVALID_HARDWARE_VERSION should be used. Ver.: always */ -void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId* currentImageInfo, - uint16_t* hardwareVersion); +void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId * currentImageInfo, uint16_t * hardwareVersion); /** @brief Ota Page Request Server Policy * * This callback is called by the OTA server page request code when it wants to @@ -977,7 +912,7 @@ uint8_t emberAfOtaPageRequestServerPolicyCallback(void); * This function provides a way for the server to adjust the block size of its * response to an Image block request by a client. * - * @param clientNodeId The node Id of OTA client making an image block request. + * @param clientNodeId The node Id of OTA client making an image block request. * Ver.: always */ uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId); @@ -990,7 +925,7 @@ uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId); * @param message A pointer to the structure containing the message buffer and * other information about it. Ver.: always */ -bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message); +bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand * message); /** @brief Ota Server Query * * This callback is fired when the OTA server receives a query request by the @@ -1006,9 +941,8 @@ bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand *message); * @param nextUpgradeImageId This is a pointer to a data structure containing * the 'next' software version for the client to download. Ver.: always */ -uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, - uint16_t* hardwareVersion, - EmberAfOtaImageId* nextUpgradeImageId); +uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId * currentImageId, uint16_t * hardwareVersion, + EmberAfOtaImageId * nextUpgradeImageId); /** @brief Ota Server Send Image Notify * * This callback is an indication to the OTA server that it should send out @@ -1019,7 +953,7 @@ uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, * @param endpoint The destination endpoint of the image notify message. May be * a broadcast endpoint. Ver.: always * @param payloadType The type of data the image notify message will contain. 0 - * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. + * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. * 3 = Manufacturer ID, image type ID, and firmware version. Ver.: always * @param queryJitter The percentage of nodes that should respond to this * message, from 1-100. On receipt of this message, each recipient will @@ -1029,18 +963,15 @@ uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId* currentImageId, * within this struct that will be appended to the message is determined by the * previous 'payloadType' argument. Ver.: always */ -bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, - uint8_t endpoint, - uint8_t payloadType, - uint8_t queryJitter, - const EmberAfOtaImageId* id); +bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, uint8_t endpoint, uint8_t payloadType, uint8_t queryJitter, + const EmberAfOtaImageId * id); /** @brief Ota Server Upgrade End Request * * This function is called when the OTA server receives a request an upgrade end * request. If the request indicated a successful download by the client, the * server must tell the client when and if to upgrade to the downloaded image. * - * @param source The node ID of the device that sent the upgrade end request. + * @param source The node ID of the device that sent the upgrade end request. * Ver.: always * @param status This is the ZCL status sent by the client indicating the result * of its attempt to download the new upgrade image. If the status is not @@ -1052,10 +983,8 @@ bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, * @param imageId This variable indicates the software version that the client * successfully downloaded and is asking to upgrade to. Ver.: always */ -bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, - uint8_t status, - uint32_t* returnValue, - const EmberAfOtaImageId* imageId); +bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, uint8_t status, uint32_t * returnValue, + const EmberAfOtaImageId * imageId); /** @brief Ota Storage Check Temp Data * * This callback will validate temporary data in the storage device to determine @@ -1077,9 +1006,8 @@ bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, * @param newFileInfo This is the image id of the temporary file data stored in * the storage device. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t* currentOffset, - uint32_t* totalImageSize, - EmberAfOtaImageId* newFileInfo); +EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t * currentOffset, uint32_t * totalImageSize, + EmberAfOtaImageId * newFileInfo); /** @brief Ota Storage Clear Temp Data * * This function clears any existing temp data that was downloaed. It is used @@ -1131,14 +1059,12 @@ EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(v * * @param offset The address offset from the start of the storage device where * data is to be read. Ver.: always - * @param length The length of the data to be read from the storage device. + * @param length The length of the data to be read from the storage device. * Ver.: always * @param returnData A pointer where the data read from the device should be * written to. Ver.: always */ -bool emberAfOtaStorageDriverReadCallback(uint32_t offset, - uint32_t length, - uint8_t* returnData); +bool emberAfOtaStorageDriverReadCallback(uint32_t offset, uint32_t length, uint8_t * returnData); /** @brief Ota Storage Driver Retrieve Last Stored Offset * * This callback defines the low-level means by which a device retrieves the @@ -1156,17 +1082,15 @@ uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void); * device. Ver.: always * @param offset The address offset from the start of the storage device where * data will be written. Ver.: always - * @param length The length of the data to be written to the storage device. + * @param length The length of the data to be written to the storage device. * Ver.: always */ -bool emberAfOtaStorageDriverWriteCallback(const uint8_t* dataToWrite, - uint32_t offset, - uint32_t length); +bool emberAfOtaStorageDriverWriteCallback(const uint8_t * dataToWrite, uint32_t offset, uint32_t length); /** @brief Ota Storage Finish Download * * This function indicates to the storage module that the download has finished. * - * @param offset The final offset of the downloaded file (i.e. the total size) + * @param offset The final offset of the downloaded file (i.e. the total size) * Ver.: always */ EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset); @@ -1187,8 +1111,7 @@ uint8_t emberAfOtaStorageGetCountCallback(void); * @param returnData This is a pointer to the location of the structure that * will be populated with data. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId* id, - EmberAfOtaHeader* returnData); +EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId * id, EmberAfOtaHeader * returnData); /** @brief Ota Storage Get Total Image Size * * This function returns the total size of the ZigBee Over-the-air file with the @@ -1197,7 +1120,7 @@ EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaI * @param id A pointer to the image identifier for the OTA file to retrieve * information for. Ver.: always */ -uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId* id); +uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId * id); /** @brief Ota Storage Init * * This callback initializes the ZigBee Over-the-air storage module. @@ -1236,11 +1159,8 @@ EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void); * of data read will be written to. A short read may occur if the end of file * was reached. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId* id, - uint32_t offset, - uint32_t length, - uint8_t* returnData, - uint32_t* returnedLength); +EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId * id, uint32_t offset, uint32_t length, + uint8_t * returnData, uint32_t * returnedLength); /** @brief Ota Storage Search * * This callback searches through the list of all images for one that matches @@ -1259,9 +1179,7 @@ EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaI * version is present in an OTA file but the other parameters match, the file * will be considered a match Ver.: always */ -EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, - uint16_t imageTypeId, - const uint16_t* hardwareVersion); +EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, uint16_t imageTypeId, const uint16_t * hardwareVersion); /** @brief Ota Storage Write Temp Data * * This function writes to the temporary data in the storage device at the @@ -1273,9 +1191,7 @@ EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, * @param data A pointer to the temporary data that will be written to the * storage device. Ver.: always */ -EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, - uint32_t length, - const uint8_t* data); +EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, uint32_t length, const uint8_t * data); /** @brief Outgoing Packet Filter * * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** @@ -1289,7 +1205,7 @@ EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, * If the stack receives an 802.15.4 MAC beacon, it will call this function with * the packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. - + * The implementation of this callback may alter the data contained in * packetData, modify options and flags in the auxillary data, or consume the * packet itself, either sending the message, or discarding it as it sees fit. @@ -1301,10 +1217,8 @@ EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, * @param size_p a pointer containing the size value of the packet Ver.: always * @param data auxillary data included with the packet Ver.: always */ -EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, - uint8_t* packetData, - uint8_t* size_p, - void* data); +EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data); /** @brief Partner Link Key Exchange Request * * This function is called by the framework on SOC platforms when a remote node @@ -1327,8 +1241,7 @@ EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner); * @param sender The EUI of the remote node. Ver.: always * @param status The ZDO response status. Ver.: always */ -void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, - EmberZdoStatus status); +void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, EmberZdoStatus status); /** @brief Performing Key Establishment * * This function is called by the framework to determine if the device is @@ -1352,14 +1265,8 @@ bool emberAfPerformingKeyEstablishmentCallback(void); * @param size Ver.: always * @param value Ver.: always */ -void emberAfPostAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t type, - uint8_t size, - uint8_t* value); +void emberAfPostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value); /** @brief Post Em4 Reset * * A callback called by application framework, and implemented by em4 plugin @@ -1383,21 +1290,16 @@ void emberAfPostEm4ResetCallback(void); * @param size Ver.: always * @param value Ver.: always */ -EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - uint8_t type, - uint8_t size, - uint8_t* value); +EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, + uint8_t * value); /** @brief Pre Cli Send * * This function is called by the framework when it is about to pass a message * constructed over CLI to the stack primitives for sending. If the function * returns true it is assumed that the callback has consumed and processed the * message. The framework will not do any further processing on the message. - + * If the function returns false then it is assumed that the callback has * not processed the message and the framework will continue to process * accordingly. @@ -1408,10 +1310,7 @@ EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, * @param message Pointer to the message payload Ver.: always * @param messageLength Length of the message payload Ver.: always */ -bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, - EmberNodeId source, - EmberNodeId destination, - uint8_t* message, +bool emberAfPreCliSendCallback(EmberApsFrame * apsFrame, EmberNodeId source, EmberNodeId destination, uint8_t * message, uint16_t messageLength); /** @brief Pre Command Received * @@ -1426,7 +1325,7 @@ bool emberAfPreCliSendCallback(EmberApsFrame* apsFrame, * * @param cmd Ver.: always */ -bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd); /** @brief Pre Message Received * * This callback is the first in the Application Framework's message processing @@ -1434,8 +1333,8 @@ bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); * over the air but has not yet been parsed by the ZCL command-handling code. If * you wish to parse some messages that are completely outside the ZCL * specification or are not handled by the Application Framework's command - * handling code, you should intercept them for parsing in this callback. - + * handling code, you should intercept them for parsing in this callback. + * This callback returns a Boolean value indicating whether or not the message * has been handled. If the callback returns a value of true, then the * Application Framework assumes that the message has been handled and it does @@ -1450,7 +1349,7 @@ bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); * * @param incomingMessage Ver.: always */ -bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage); +bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage * incomingMessage); /** @brief Pre Message Send * * This function is called by the framework when it is about to pass a message @@ -1470,8 +1369,7 @@ bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage* incomingMessage); * @param status A pointer to the status code value that will be returned to the * caller. Ver.: always */ -bool emberAfPreMessageSendCallback(EmberAfMessageStruct* messageStruct, - EmberStatus* status); +bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status); /** @brief Pre Ncp Reset * * This function will be called prior to the reset of the NCP by the host. @@ -1490,10 +1388,7 @@ void emberAfPreNcpResetCallback(void); * @param message Ver.: always * @param length Ver.: always */ -bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, - EmberApsFrame* apsFrame, - uint8_t* message, - uint16_t length); +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length); /** @brief Read Attributes Response * * This function is called by the application framework when a Read Attributes @@ -1501,13 +1396,11 @@ bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, * return true if the message was processed or false if it was not. * * @param clusterId The cluster identifier of this response. Ver.: always - * @param buffer Buffer containing the list of read attribute status records. + * @param buffer Buffer containing the list of read attribute status records. * Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen); +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); /** @brief Read Reporting Configuration Command * * This function is called by the application framework when a Read Reporting @@ -1516,7 +1409,7 @@ bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, * * @param cmd Ver.: always */ -bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand *cmd); +bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand * cmd); /** @brief Read Reporting Configuration Response * * This function is called by the application framework when a Read Reporting @@ -1529,9 +1422,7 @@ bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterComman * records. Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen); +bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); /** @brief Registration Abort * * This callback is called when the device should abort the registration @@ -1576,7 +1467,7 @@ EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index); * * @param entry Ember Binding Tablet Entry Ver.: always */ -EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry *entry); +EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry * entry); /** @brief Remove From Current App Tasks * * This function is only useful to sleepy end devices. This function will @@ -1601,9 +1492,7 @@ void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks); * always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen); +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); /** @brief Reporting Attribute Change * * This function is called by the framework when an attribute managed by the @@ -1619,13 +1508,8 @@ bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, * @param type Ver.: always * @param data Ver.: always */ -void emberAfReportingAttributeChangeCallback(uint8_t endpoint, - EmberAfClusterId clusterId, - EmberAfAttributeId attributeId, - uint8_t mask, - uint16_t manufacturerCode, - EmberAfAttributeType type, - uint8_t *data); +void emberAfReportingAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, EmberAfAttributeType type, uint8_t * data); /** @brief Scan Complete * * This is called by the low-level stack code when an 802.15.4 active scan @@ -1635,8 +1519,7 @@ void emberAfReportingAttributeChangeCallback(uint8_t endpoint, * error occurred. Otherwise it is undefined for EMBER_SUCCESS. Ver.: always * @param status The status of the scan. Ver.: always */ -void emberAfScanCompleteCallback(uint8_t channel, - EmberStatus status); +void emberAfScanCompleteCallback(uint8_t channel, EmberStatus status); /** @brief Scan Error * * This is called by the framework on behalf of the form-and-join library to @@ -1649,7 +1532,7 @@ void emberAfScanErrorCallback(EmberStatus status); /** @brief Security Init * * This callback is called by the framework to give the application a chance to - * modify the security settings of the node during network initialization. + * modify the security settings of the node during network initialization. * Depending on the context when this callback is called, the pointer to the * initial security state may be NULL, which means the initial security state * can no longer be modified as the node is already operating on the network. @@ -1658,9 +1541,7 @@ void emberAfScanErrorCallback(EmberStatus status); * @param extended Ver.: always * @param trustCenter Ver.: always */ -void emberAfSecurityInitCallback(EmberInitialSecurityState *state, - EmberExtendedSecurityBitmask *extended, - bool trustCenter); +void emberAfSecurityInitCallback(EmberInitialSecurityState * state, EmberExtendedSecurityBitmask * extended, bool trustCenter); /** @brief Set Default Poll Control * * This function will set the default poll control for the current network to @@ -1687,7 +1568,7 @@ void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control); * * @param extendedPanId Ver.: always */ -void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t *extendedPanId); +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t * extendedPanId); /** @brief Set Long Poll Interval Ms * * This function is only useful to end devices. This function will set the long @@ -1737,8 +1618,7 @@ void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs); * @param destination The node id of the destination Ver.: always * @param overhead The overhead in bytes Ver.: always */ -void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, - uint8_t overhead); +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, uint8_t overhead); /** @brief Set Time * * This callback should be implemented, if the device has access to real time @@ -1828,11 +1708,8 @@ void emberAfStopMoveCallback(void); * @param status Ver.: always * @param decision Ver.: always */ -void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, - EmberEUI64 newNodeEui64, - EmberNodeId parentOfNewNode, - EmberDeviceUpdate status, - EmberJoinDecision decision); +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, EmberEUI64 newNodeEui64, EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, EmberJoinDecision decision); /** @brief Trust Center Keepalive Abort * * This callback is called when the device should abort the trust center @@ -1861,8 +1738,7 @@ void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete); * @param panId Ver.: always * @param channel Ver.: always */ -void emberAfUnusedPanIdFoundCallback(EmberPanId panId, - uint8_t channel); +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, uint8_t channel); /** @brief Write Attributes Response * * This function is called by the application framework when a Write Attributes @@ -1870,13 +1746,11 @@ void emberAfUnusedPanIdFoundCallback(EmberPanId panId, * return true if the message was processed or false if it was not. * * @param clusterId The cluster identifier of this response. Ver.: always - * @param buffer Buffer containing the list of write attribute status records. + * @param buffer Buffer containing the list of write attribute status records. * Ver.: always * @param bufLen The length in bytes of the list. Ver.: always */ -bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, - uint8_t *buffer, - uint16_t bufLen); +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); /** @brief Zigbee Key Establishment * * A callback to the application to notify it of the status of the request for a @@ -1886,8 +1760,7 @@ bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, * if the Key establishment failed. Ver.: always * @param status The status of the key establishment. Ver.: always */ -void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, - EmberKeyStatus status); +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); /** @} END Non-Cluster Related Callbacks */ /** @name Basic Cluster Callbacks */ @@ -1900,8 +1773,7 @@ void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBasicClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBasicClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Basic Cluster Client Default Response * * This function is called when the client receives the default response from @@ -1911,9 +1783,7 @@ void emberAfBasicClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBasicClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBasicClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Basic Cluster Client Init * * Client Init @@ -1927,11 +1797,10 @@ void emberAfBasicClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Basic Cluster Client Message Sent * @@ -1945,12 +1814,8 @@ void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Basic Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -1961,11 +1826,9 @@ void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Basic Cluster Client Tick * * Client Tick @@ -1975,25 +1838,23 @@ EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(uint8_t endpo void emberAfBasicClusterClientTickCallback(uint8_t endpoint); /** @brief Basic Cluster Get Locales Supported * - * + * * * @param startLocale Ver.: always * @param maxLocalesRequested Ver.: always */ -bool emberAfBasicClusterGetLocalesSupportedCallback(uint8_t* startLocale, - uint8_t maxLocalesRequested); +bool emberAfBasicClusterGetLocalesSupportedCallback(uint8_t * startLocale, uint8_t maxLocalesRequested); /** @brief Basic Cluster Get Locales Supported Response * - * + * * * @param discoveryComplete Ver.: always * @param localeSupported Ver.: always */ -bool emberAfBasicClusterGetLocalesSupportedResponseCallback(uint8_t discoveryComplete, - uint8_t* localeSupported); +bool emberAfBasicClusterGetLocalesSupportedResponseCallback(uint8_t discoveryComplete, uint8_t * localeSupported); /** @brief Basic Cluster Reset To Factory Defaults * - * + * * */ bool emberAfBasicClusterResetToFactoryDefaultsCallback(void); @@ -2004,8 +1865,7 @@ bool emberAfBasicClusterResetToFactoryDefaultsCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBasicClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBasicClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Basic Cluster Server Default Response * * This function is called when the server receives the default response from @@ -2015,9 +1875,7 @@ void emberAfBasicClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBasicClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBasicClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Basic Cluster Server Init * * Server Init @@ -2031,11 +1889,10 @@ void emberAfBasicClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Basic Cluster Server Message Sent * @@ -2049,12 +1906,8 @@ void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Basic Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -2065,11 +1918,9 @@ void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Basic Cluster Server Tick * * Server Tick @@ -2090,8 +1941,7 @@ void emberAfBasicClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPowerConfigClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPowerConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Power Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -2101,9 +1951,7 @@ void emberAfPowerConfigClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPowerConfigClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPowerConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Power Configuration Cluster Client Init * * Client Init @@ -2117,11 +1965,10 @@ void emberAfPowerConfigClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPowerConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPowerConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Power Configuration Cluster Client Message Sent * @@ -2135,11 +1982,8 @@ void emberAfPowerConfigClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPowerConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPowerConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Power Configuration Cluster Client Pre Attribute Changed * @@ -2151,11 +1995,9 @@ void emberAfPowerConfigClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPowerConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPowerConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Power Configuration Cluster Client Tick * * Client Tick @@ -2170,8 +2012,7 @@ void emberAfPowerConfigClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPowerConfigClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPowerConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Power Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -2181,9 +2022,7 @@ void emberAfPowerConfigClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPowerConfigClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPowerConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Power Configuration Cluster Server Init * * Server Init @@ -2197,11 +2036,10 @@ void emberAfPowerConfigClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPowerConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPowerConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Power Configuration Cluster Server Message Sent * @@ -2215,11 +2053,8 @@ void emberAfPowerConfigClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPowerConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPowerConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Power Configuration Cluster Server Pre Attribute Changed * @@ -2231,11 +2066,9 @@ void emberAfPowerConfigClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPowerConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPowerConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Power Configuration Cluster Server Tick * * Server Tick @@ -2256,8 +2089,7 @@ void emberAfPowerConfigClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDeviceTempClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDeviceTempClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Device Temperature Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -2267,9 +2099,7 @@ void emberAfDeviceTempClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDeviceTempClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDeviceTempClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Device Temperature Configuration Cluster Client Init * * Client Init @@ -2283,11 +2113,10 @@ void emberAfDeviceTempClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDeviceTempClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDeviceTempClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Device Temperature Configuration Cluster Client Message Sent * @@ -2301,11 +2130,8 @@ void emberAfDeviceTempClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDeviceTempClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDeviceTempClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Device Temperature Configuration Cluster Client Pre Attribute Changed * @@ -2317,11 +2143,9 @@ void emberAfDeviceTempClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDeviceTempClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDeviceTempClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Device Temperature Configuration Cluster Client Tick * * Client Tick @@ -2336,8 +2160,7 @@ void emberAfDeviceTempClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDeviceTempClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDeviceTempClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Device Temperature Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -2347,9 +2170,7 @@ void emberAfDeviceTempClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDeviceTempClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDeviceTempClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Device Temperature Configuration Cluster Server Init * * Server Init @@ -2363,11 +2184,10 @@ void emberAfDeviceTempClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDeviceTempClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDeviceTempClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Device Temperature Configuration Cluster Server Message Sent * @@ -2381,11 +2201,8 @@ void emberAfDeviceTempClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDeviceTempClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDeviceTempClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Device Temperature Configuration Cluster Server Pre Attribute Changed * @@ -2397,11 +2214,9 @@ void emberAfDeviceTempClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDeviceTempClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDeviceTempClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Device Temperature Configuration Cluster Server Tick * * Server Tick @@ -2422,8 +2237,7 @@ void emberAfDeviceTempClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIdentifyClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIdentifyClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Identify Cluster Client Default Response * * This function is called when the client receives the default response from @@ -2433,9 +2247,7 @@ void emberAfIdentifyClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIdentifyClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIdentifyClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Identify Cluster Client Init * * Client Init @@ -2449,11 +2261,10 @@ void emberAfIdentifyClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Identify Cluster Client Message Sent * @@ -2467,11 +2278,8 @@ void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Identify Cluster Client Pre Attribute Changed * @@ -2483,11 +2291,9 @@ void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Identify Cluster Client Tick * * Client Tick @@ -2497,27 +2303,27 @@ EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(uint8_t en void emberAfIdentifyClusterClientTickCallback(uint8_t endpoint); /** @brief Identify Cluster E Z Mode Invoke * - * + * * * @param action Ver.: always */ bool emberAfIdentifyClusterEZModeInvokeCallback(uint8_t action); /** @brief Identify Cluster Identify * - * + * * * @param identifyTime Ver.: always */ bool emberAfIdentifyClusterIdentifyCallback(uint16_t identifyTime); /** @brief Identify Cluster Identify Query * - * + * * */ bool emberAfIdentifyClusterIdentifyQueryCallback(void); /** @brief Identify Cluster Identify Query Response * - * + * * * @param timeout Ver.: always */ @@ -2529,8 +2335,7 @@ bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIdentifyClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIdentifyClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Identify Cluster Server Default Response * * This function is called when the server receives the default response from @@ -2540,9 +2345,7 @@ void emberAfIdentifyClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIdentifyClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIdentifyClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Identify Cluster Server Init * * Server Init @@ -2556,11 +2359,10 @@ void emberAfIdentifyClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Identify Cluster Server Message Sent * @@ -2574,11 +2376,8 @@ void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Identify Cluster Server Pre Attribute Changed * @@ -2590,11 +2389,9 @@ void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Identify Cluster Server Tick * * Server Tick @@ -2604,22 +2401,20 @@ EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(uint8_t en void emberAfIdentifyClusterServerTickCallback(uint8_t endpoint); /** @brief Identify Cluster Trigger Effect * - * + * * * @param effectId Ver.: always * @param effectVariant Ver.: always */ -bool emberAfIdentifyClusterTriggerEffectCallback(uint8_t effectId, - uint8_t effectVariant); +bool emberAfIdentifyClusterTriggerEffectCallback(uint8_t effectId, uint8_t effectVariant); /** @brief Identify Cluster Update Commission State * - * + * * * @param action Ver.: always * @param commissionStateMask Ver.: always */ -bool emberAfIdentifyClusterUpdateCommissionStateCallback(uint8_t action, - uint8_t commissionStateMask); +bool emberAfIdentifyClusterUpdateCommissionStateCallback(uint8_t action, uint8_t commissionStateMask); /** @} END Identify Cluster Callbacks */ @@ -2643,35 +2438,31 @@ void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint); * @param endpoint The endpoint. Ver.: always * @param groupId The group identifier. Ver.: always */ -bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, - uint16_t groupId); +bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, uint16_t groupId); /** @brief Groups Cluster Add Group * - * + * * * @param groupId Ver.: always * @param groupName Ver.: always */ -bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, - uint8_t* groupName); +bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, uint8_t * groupName); /** @brief Groups Cluster Add Group If Identifying * - * + * * * @param groupId Ver.: always * @param groupName Ver.: always */ -bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, - uint8_t* groupName); +bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, uint8_t * groupName); /** @brief Groups Cluster Add Group Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always */ -bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, - uint16_t groupId); +bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId); /** @brief Groups Cluster Client Attribute Changed * * Client Attribute Changed @@ -2679,8 +2470,7 @@ bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGroupsClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGroupsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Groups Cluster Client Default Response * * This function is called when the client receives the default response from @@ -2690,9 +2480,7 @@ void emberAfGroupsClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGroupsClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGroupsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Groups Cluster Client Init * * Client Init @@ -2706,11 +2494,10 @@ void emberAfGroupsClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Groups Cluster Client Message Sent * @@ -2724,11 +2511,8 @@ void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Groups Cluster Client Pre Attribute Changed * @@ -2740,11 +2524,9 @@ void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Groups Cluster Client Tick * * Client Tick @@ -2754,46 +2536,42 @@ EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfGroupsClusterClientTickCallback(uint8_t endpoint); /** @brief Groups Cluster Get Group Membership * - * + * * * @param groupCount Ver.: always * @param groupList Ver.: always */ -bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount, - uint8_t* groupList); +bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount, uint8_t * groupList); /** @brief Groups Cluster Get Group Membership Response * - * + * * * @param capacity Ver.: always * @param groupCount Ver.: always * @param groupList Ver.: always */ -bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, - uint8_t groupCount, - uint8_t* groupList); +bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount, uint8_t * groupList); /** @brief Groups Cluster Remove All Groups * - * + * * */ bool emberAfGroupsClusterRemoveAllGroupsCallback(void); /** @brief Groups Cluster Remove Group * - * + * * * @param groupId Ver.: always */ bool emberAfGroupsClusterRemoveGroupCallback(uint16_t groupId); /** @brief Groups Cluster Remove Group Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always */ -bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, - uint16_t groupId); +bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId); /** @brief Groups Cluster Server Attribute Changed * * Server Attribute Changed @@ -2801,8 +2579,7 @@ bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGroupsClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGroupsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Groups Cluster Server Default Response * * This function is called when the server receives the default response from @@ -2812,9 +2589,7 @@ void emberAfGroupsClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGroupsClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGroupsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Groups Cluster Server Init * * Server Init @@ -2828,11 +2603,10 @@ void emberAfGroupsClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Groups Cluster Server Message Sent * @@ -2846,11 +2620,8 @@ void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Groups Cluster Server Pre Attribute Changed * @@ -2862,11 +2633,9 @@ void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Groups Cluster Server Tick * * Server Tick @@ -2876,22 +2645,20 @@ EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfGroupsClusterServerTickCallback(uint8_t endpoint); /** @brief Groups Cluster View Group * - * + * * * @param groupId Ver.: always */ bool emberAfGroupsClusterViewGroupCallback(uint16_t groupId); /** @brief Groups Cluster View Group Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always * @param groupName Ver.: always */ -bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t* groupName); +bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName); /** @} END Groups Cluster Callbacks */ @@ -2923,9 +2690,7 @@ EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint); * @param groupId The group identifier. Ver.: always * @param sceneId The scene identifier. Ver.: always */ -EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, - uint16_t groupId, - uint8_t sceneId); +EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Remove Scenes In Group * * This function removes the scenes from a specified group. @@ -2933,11 +2698,10 @@ EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, * @param endpoint Endpoint Ver.: always * @param groupId Group ID Ver.: always */ -void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, - uint16_t groupId); +void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, uint16_t groupId); /** @brief Scenes Cluster Add Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always @@ -2945,22 +2709,17 @@ void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, * @param sceneName Ver.: always * @param extensionFieldSets Ver.: always */ -bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, - uint8_t sceneId, - uint16_t transitionTime, - uint8_t* sceneName, - uint8_t* extensionFieldSets); +bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); /** @brief Scenes Cluster Add Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Client Attribute Changed * * Client Attribute Changed @@ -2968,8 +2727,7 @@ bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfScenesClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfScenesClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Scenes Cluster Client Default Response * * This function is called when the client receives the default response from @@ -2979,9 +2737,7 @@ void emberAfScenesClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfScenesClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfScenesClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Scenes Cluster Client Init * * Client Init @@ -2995,11 +2751,10 @@ void emberAfScenesClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Scenes Cluster Client Message Sent * @@ -3013,11 +2768,8 @@ void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Scenes Cluster Client Pre Attribute Changed * @@ -3029,11 +2781,9 @@ void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Scenes Cluster Client Tick * * Client Tick @@ -3043,7 +2793,7 @@ EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfScenesClusterClientTickCallback(uint8_t endpoint); /** @brief Scenes Cluster Copy Scene * - * + * * * @param mode Ver.: always * @param groupIdFrom Ver.: always @@ -3051,25 +2801,20 @@ void emberAfScenesClusterClientTickCallback(uint8_t endpoint); * @param groupIdTo Ver.: always * @param sceneIdTo Ver.: always */ -bool emberAfScenesClusterCopySceneCallback(uint8_t mode, - uint16_t groupIdFrom, - uint8_t sceneIdFrom, - uint16_t groupIdTo, - uint8_t sceneIdTo); +bool emberAfScenesClusterCopySceneCallback(uint8_t mode, uint16_t groupIdFrom, uint8_t sceneIdFrom, uint16_t groupIdTo, + uint8_t sceneIdTo); /** @brief Scenes Cluster Copy Scene Response * - * + * * * @param status Ver.: always * @param groupIdFrom Ver.: always * @param sceneIdFrom Ver.: always */ -bool emberAfScenesClusterCopySceneResponseCallback(uint8_t status, - uint16_t groupIdFrom, - uint8_t sceneIdFrom); +bool emberAfScenesClusterCopySceneResponseCallback(uint8_t status, uint16_t groupIdFrom, uint8_t sceneIdFrom); /** @brief Scenes Cluster Enhanced Add Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always @@ -3077,34 +2822,28 @@ bool emberAfScenesClusterCopySceneResponseCallback(uint8_t status, * @param sceneName Ver.: always * @param extensionFieldSets Ver.: always */ -bool emberAfScenesClusterEnhancedAddSceneCallback(uint16_t groupId, - uint8_t sceneId, - uint16_t transitionTime, - uint8_t* sceneName, - uint8_t* extensionFieldSets); +bool emberAfScenesClusterEnhancedAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); /** @brief Scenes Cluster Enhanced Add Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterEnhancedAddSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterEnhancedAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Enhanced View Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterEnhancedViewSceneCallback(uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterEnhancedViewSceneCallback(uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Enhanced View Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always @@ -3113,22 +2852,19 @@ bool emberAfScenesClusterEnhancedViewSceneCallback(uint16_t groupId, * @param sceneName Ver.: always * @param extensionFieldSets Ver.: always */ -bool emberAfScenesClusterEnhancedViewSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId, - uint16_t transitionTime, - uint8_t* sceneName, - uint8_t* extensionFieldSets); +bool emberAfScenesClusterEnhancedViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, + uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); /** @brief Scenes Cluster Get Scene Membership * - * + * * * @param groupId Ver.: always */ bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId); /** @brief Scenes Cluster Get Scene Membership Response * - * + * * * @param status Ver.: always * @param capacity Ver.: always @@ -3136,58 +2872,49 @@ bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId); * @param sceneCount Ver.: always * @param sceneList Ver.: always */ -bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, - uint8_t capacity, - uint16_t groupId, - uint8_t sceneCount, - uint8_t* sceneList); +bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, uint8_t capacity, uint16_t groupId, uint8_t sceneCount, + uint8_t * sceneList); /** @brief Scenes Cluster Recall Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always * @param transitionTime Ver.: since zcl-7.0-07-5123-07 */ -bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, - uint8_t sceneId, - uint16_t transitionTime); +bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime); /** @brief Scenes Cluster Remove All Scenes * - * + * * * @param groupId Ver.: always */ bool emberAfScenesClusterRemoveAllScenesCallback(uint16_t groupId); /** @brief Scenes Cluster Remove All Scenes Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always */ -bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, - uint16_t groupId); +bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId); /** @brief Scenes Cluster Remove Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Remove Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Server Attribute Changed * * Server Attribute Changed @@ -3195,8 +2922,7 @@ bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfScenesClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfScenesClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Scenes Cluster Server Default Response * * This function is called when the server receives the default response from @@ -3206,9 +2932,7 @@ void emberAfScenesClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfScenesClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfScenesClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Scenes Cluster Server Init * * Server Init @@ -3222,11 +2946,10 @@ void emberAfScenesClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Scenes Cluster Server Message Sent * @@ -3240,11 +2963,8 @@ void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Scenes Cluster Server Pre Attribute Changed * @@ -3256,11 +2976,9 @@ void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Scenes Cluster Server Tick * * Server Tick @@ -3270,36 +2988,32 @@ EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfScenesClusterServerTickCallback(uint8_t endpoint); /** @brief Scenes Cluster Store Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster Store Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster View Scene * - * + * * * @param groupId Ver.: always * @param sceneId Ver.: always */ -bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, - uint8_t sceneId); +bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, uint8_t sceneId); /** @brief Scenes Cluster View Scene Response * - * + * * * @param status Ver.: always * @param groupId Ver.: always @@ -3308,12 +3022,8 @@ bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, * @param sceneName Ver.: always * @param extensionFieldSets Ver.: always */ -bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, - uint16_t groupId, - uint8_t sceneId, - uint16_t transitionTime, - uint8_t* sceneName, - uint8_t* extensionFieldSets); +bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, + uint8_t * sceneName, uint8_t * extensionFieldSets); /** @brief Scenes Cluster Store Current Scene * * This function is called by the framework when the application should store @@ -3326,9 +3036,7 @@ bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, * @param groupId The group identifier. Ver.: always * @param sceneId The scene identifier. Ver.: always */ -EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, - uint16_t groupId, - uint8_t sceneId); +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId); /** @} END Scenes Cluster Callbacks */ @@ -3344,8 +3052,7 @@ EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, * @param endpoint Ver.: always * @param newValue Ver.: always */ -void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, - bool newValue); +void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, bool newValue); /** @brief On/off Cluster Client Attribute Changed * * Client Attribute Changed @@ -3353,8 +3060,7 @@ void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOnOffClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOnOffClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief On/off Cluster Client Default Response * * This function is called when the client receives the default response from @@ -3364,9 +3070,7 @@ void emberAfOnOffClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOnOffClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOnOffClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief On/off Cluster Client Init * * Client Init @@ -3380,11 +3084,10 @@ void emberAfOnOffClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief On/off Cluster Client Message Sent * @@ -3398,12 +3101,8 @@ void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief On/off Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -3414,11 +3113,9 @@ void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief On/off Cluster Client Tick * * Client Tick @@ -3428,69 +3125,66 @@ EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(uint8_t endpo void emberAfOnOffClusterClientTickCallback(uint8_t endpoint); /** @brief On/off Cluster Off * - * + * * */ bool emberAfOnOffClusterOffCallback(void); /** @brief On/off Cluster Off With Effect * - * + * * * @param effectId Ver.: always * @param effectVariant Ver.: always */ -bool emberAfOnOffClusterOffWithEffectCallback(uint8_t effectId, - uint8_t effectVariant); +bool emberAfOnOffClusterOffWithEffectCallback(uint8_t effectId, uint8_t effectVariant); /** @brief On/off Cluster On * - * + * * */ bool emberAfOnOffClusterOnCallback(void); /** @brief On/off Cluster On With Recall Global Scene * - * + * * */ bool emberAfOnOffClusterOnWithRecallGlobalSceneCallback(void); /** @brief On/off Cluster On With Timed Off * - * + * * * @param onOffControl Ver.: always * @param onTime Ver.: always * @param offWaitTime Ver.: always */ -bool emberAfOnOffClusterOnWithTimedOffCallback(uint8_t onOffControl, - uint16_t onTime, - uint16_t offWaitTime); +bool emberAfOnOffClusterOnWithTimedOffCallback(uint8_t onOffControl, uint16_t onTime, uint16_t offWaitTime); /** @brief On/off Cluster Sample Mfg Specific Off With Transition * - * + * * */ bool emberAfOnOffClusterSampleMfgSpecificOffWithTransitionCallback(void); /** @brief On/off Cluster Sample Mfg Specific On With Transition2 * - * + * * */ bool emberAfOnOffClusterSampleMfgSpecificOnWithTransition2Callback(void); /** @brief On/off Cluster Sample Mfg Specific On With Transition * - * + * * */ bool emberAfOnOffClusterSampleMfgSpecificOnWithTransitionCallback(void); /** @brief On/off Cluster Sample Mfg Specific Toggle With Transition2 * - * + * * */ bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransition2Callback(void); /** @brief On/off Cluster Sample Mfg Specific Toggle With Transition * - * + * * */ bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransitionCallback(void); @@ -3501,8 +3195,7 @@ bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransitionCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOnOffClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOnOffClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief On/off Cluster Server Default Response * * This function is called when the server receives the default response from @@ -3512,9 +3205,7 @@ void emberAfOnOffClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOnOffClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOnOffClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief On/off Cluster Server Init * * Server Init @@ -3528,11 +3219,10 @@ void emberAfOnOffClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief On/off Cluster Server Message Sent * @@ -3546,12 +3236,8 @@ void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief On/off Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -3562,11 +3248,9 @@ void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief On/off Cluster Server Tick * * Server Tick @@ -3576,7 +3260,7 @@ EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(uint8_t endpo void emberAfOnOffClusterServerTickCallback(uint8_t endpoint); /** @brief On/off Cluster Toggle * - * + * * */ bool emberAfOnOffClusterToggleCallback(void); @@ -3589,9 +3273,7 @@ bool emberAfOnOffClusterToggleCallback(void); * @param command Ver.: always * @param initiatedByLevelChange Ver.: always */ -EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, - uint8_t command, - bool initiatedByLevelChange); +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange); /** @brief On/off Cluster Server Post Init * * Following resolution of the On/Off state at startup for this endpoint, perform any @@ -3613,8 +3295,7 @@ void emberAfPluginOnOffClusterServerPostInitCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOnOffSwitchConfigClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOnOffSwitchConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief On/off Switch Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -3624,9 +3305,7 @@ void emberAfOnOffSwitchConfigClusterClientAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOnOffSwitchConfigClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOnOffSwitchConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief On/off Switch Configuration Cluster Client Init * * Client Init @@ -3640,7 +3319,7 @@ void emberAfOnOffSwitchConfigClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOnOffSwitchConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -3658,11 +3337,8 @@ void emberAfOnOffSwitchConfigClusterClientManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOnOffSwitchConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOnOffSwitchConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief On/off Switch Configuration Cluster Client Pre Attribute Changed * @@ -3674,11 +3350,9 @@ void emberAfOnOffSwitchConfigClusterClientMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOnOffSwitchConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOnOffSwitchConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief On/off Switch Configuration Cluster Client Tick * * Client Tick @@ -3693,8 +3367,7 @@ void emberAfOnOffSwitchConfigClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOnOffSwitchConfigClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOnOffSwitchConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief On/off Switch Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -3704,9 +3377,7 @@ void emberAfOnOffSwitchConfigClusterServerAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOnOffSwitchConfigClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOnOffSwitchConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief On/off Switch Configuration Cluster Server Init * * Server Init @@ -3720,7 +3391,7 @@ void emberAfOnOffSwitchConfigClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOnOffSwitchConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -3738,11 +3409,8 @@ void emberAfOnOffSwitchConfigClusterServerManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOnOffSwitchConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOnOffSwitchConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief On/off Switch Configuration Cluster Server Pre Attribute Changed * @@ -3754,11 +3422,9 @@ void emberAfOnOffSwitchConfigClusterServerMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOnOffSwitchConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOnOffSwitchConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief On/off Switch Configuration Cluster Server Tick * * Server Tick @@ -3779,8 +3445,7 @@ void emberAfOnOffSwitchConfigClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfLevelControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfLevelControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Level Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -3790,9 +3455,7 @@ void emberAfLevelControlClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfLevelControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfLevelControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Level Control Cluster Client Init * * Client Init @@ -3806,11 +3469,10 @@ void emberAfLevelControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Level Control Cluster Client Message Sent * @@ -3824,11 +3486,8 @@ void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Level Control Cluster Client Pre Attribute Changed * @@ -3840,11 +3499,9 @@ void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Level Control Cluster Client Tick * * Client Tick @@ -3854,48 +3511,41 @@ EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(uint8_ void emberAfLevelControlClusterClientTickCallback(uint8_t endpoint); /** @brief Level Control Cluster Move * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always * @param optionMask Ver.: since zcl6-errata-14-0129-15 * @param optionOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, - uint8_t rate, - uint8_t optionMask, - uint8_t optionOverride); +bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride); /** @brief Level Control Cluster Move To Level * - * + * * * @param level Ver.: always * @param transitionTime Ver.: always * @param optionMask Ver.: since zcl6-errata-14-0129-15 * @param optionOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, - uint16_t transitionTime, - uint8_t optionMask, - uint8_t optionOverride); +bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, uint16_t transitionTime, uint8_t optionMask, + uint8_t optionOverride); /** @brief Level Control Cluster Move To Level With On Off * - * + * * * @param level Ver.: always * @param transitionTime Ver.: always */ -bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, - uint16_t transitionTime); +bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, uint16_t transitionTime); /** @brief Level Control Cluster Move With On Off * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always */ -bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, - uint8_t rate); +bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, uint8_t rate); /** @brief Level Control Cluster Server Attribute Changed * * Server Attribute Changed @@ -3903,8 +3553,7 @@ bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfLevelControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfLevelControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Level Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -3914,9 +3563,7 @@ void emberAfLevelControlClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfLevelControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfLevelControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Level Control Cluster Server Init * * Server Init @@ -3930,11 +3577,10 @@ void emberAfLevelControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Level Control Cluster Server Message Sent * @@ -3948,11 +3594,8 @@ void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Level Control Cluster Server Pre Attribute Changed * @@ -3964,11 +3607,9 @@ void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Level Control Cluster Server Tick * * Server Tick @@ -3978,7 +3619,7 @@ EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(uint8_ void emberAfLevelControlClusterServerTickCallback(uint8_t endpoint); /** @brief Level Control Cluster Step * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always @@ -3986,34 +3627,28 @@ void emberAfLevelControlClusterServerTickCallback(uint8_t endpoint); * @param optionMask Ver.: since zcl6-errata-14-0129-15 * @param optionOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, - uint8_t stepSize, - uint16_t transitionTime, - uint8_t optionMask, - uint8_t optionOverride); +bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, + uint8_t optionOverride); /** @brief Level Control Cluster Step With On Off * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always * @param transitionTime Ver.: always */ -bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, - uint8_t stepSize, - uint16_t transitionTime); +bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime); /** @brief Level Control Cluster Stop * - * + * * * @param optionMask Ver.: since zcl6-errata-14-0129-15 * @param optionOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, - uint8_t optionOverride); +bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, uint8_t optionOverride); /** @brief Level Control Cluster Stop With On Off * - * + * * */ bool emberAfLevelControlClusterStopWithOnOffCallback(void); @@ -4025,13 +3660,12 @@ bool emberAfLevelControlClusterStopWithOnOffCallback(void); /** @brief Alarms Cluster Alarm * - * + * * * @param alarmCode Ver.: always * @param clusterId Ver.: always */ -bool emberAfAlarmClusterAlarmCallback(uint8_t alarmCode, - uint16_t clusterId); +bool emberAfAlarmClusterAlarmCallback(uint8_t alarmCode, uint16_t clusterId); /** @brief Alarms Cluster Client Attribute Changed * * Client Attribute Changed @@ -4039,8 +3673,7 @@ bool emberAfAlarmClusterAlarmCallback(uint8_t alarmCode, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfAlarmClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfAlarmClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Alarms Cluster Client Default Response * * This function is called when the client receives the default response from @@ -4050,9 +3683,7 @@ void emberAfAlarmClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfAlarmClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfAlarmClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Alarms Cluster Client Init * * Client Init @@ -4066,11 +3697,10 @@ void emberAfAlarmClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfAlarmClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfAlarmClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Alarms Cluster Client Message Sent * @@ -4084,12 +3714,8 @@ void emberAfAlarmClusterClientManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfAlarmClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfAlarmClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Alarms Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -4100,11 +3726,9 @@ void emberAfAlarmClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfAlarmClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfAlarmClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Alarms Cluster Client Tick * * Client Tick @@ -4114,41 +3738,37 @@ EmberAfStatus emberAfAlarmClusterClientPreAttributeChangedCallback(uint8_t endpo void emberAfAlarmClusterClientTickCallback(uint8_t endpoint); /** @brief Alarms Cluster Get Alarm * - * + * * */ bool emberAfAlarmClusterGetAlarmCallback(void); /** @brief Alarms Cluster Get Alarm Response * - * + * * * @param status Ver.: always * @param alarmCode Ver.: always * @param clusterId Ver.: always * @param timeStamp Ver.: always */ -bool emberAfAlarmClusterGetAlarmResponseCallback(uint8_t status, - uint8_t alarmCode, - uint16_t clusterId, - uint32_t timeStamp); +bool emberAfAlarmClusterGetAlarmResponseCallback(uint8_t status, uint8_t alarmCode, uint16_t clusterId, uint32_t timeStamp); /** @brief Alarms Cluster Reset Alarm * - * + * * * @param alarmCode Ver.: always * @param clusterId Ver.: always */ -bool emberAfAlarmClusterResetAlarmCallback(uint8_t alarmCode, - uint16_t clusterId); +bool emberAfAlarmClusterResetAlarmCallback(uint8_t alarmCode, uint16_t clusterId); /** @brief Alarms Cluster Reset Alarm Log * - * + * * */ bool emberAfAlarmClusterResetAlarmLogCallback(void); /** @brief Alarms Cluster Reset All Alarms * - * + * * */ bool emberAfAlarmClusterResetAllAlarmsCallback(void); @@ -4159,8 +3779,7 @@ bool emberAfAlarmClusterResetAllAlarmsCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfAlarmClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfAlarmClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Alarms Cluster Server Default Response * * This function is called when the server receives the default response from @@ -4170,9 +3789,7 @@ void emberAfAlarmClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfAlarmClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfAlarmClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Alarms Cluster Server Init * * Server Init @@ -4186,11 +3803,10 @@ void emberAfAlarmClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfAlarmClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfAlarmClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Alarms Cluster Server Message Sent * @@ -4204,12 +3820,8 @@ void emberAfAlarmClusterServerManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfAlarmClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfAlarmClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Alarms Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -4220,11 +3832,9 @@ void emberAfAlarmClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfAlarmClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfAlarmClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Alarms Cluster Server Tick * * Server Tick @@ -4245,8 +3855,7 @@ void emberAfAlarmClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTimeClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTimeClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Time Cluster Client Default Response * * This function is called when the client receives the default response from @@ -4256,9 +3865,7 @@ void emberAfTimeClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTimeClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTimeClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Time Cluster Client Init * * Client Init @@ -4272,11 +3879,10 @@ void emberAfTimeClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTimeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfTimeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Time Cluster Client Message Sent * @@ -4290,12 +3896,8 @@ void emberAfTimeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_ * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTimeClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfTimeClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Time Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -4306,11 +3908,9 @@ void emberAfTimeClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTimeClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTimeClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Time Cluster Client Tick * * Client Tick @@ -4325,8 +3925,7 @@ void emberAfTimeClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTimeClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTimeClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Time Cluster Server Default Response * * This function is called when the server receives the default response from @@ -4336,9 +3935,7 @@ void emberAfTimeClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTimeClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTimeClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Time Cluster Server Init * * Server Init @@ -4352,11 +3949,10 @@ void emberAfTimeClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTimeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfTimeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Time Cluster Server Message Sent * @@ -4370,12 +3966,8 @@ void emberAfTimeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_ * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTimeClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfTimeClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Time Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -4386,11 +3978,9 @@ void emberAfTimeClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTimeClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTimeClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Time Cluster Server Tick * * Server Tick @@ -4406,17 +3996,15 @@ void emberAfTimeClusterServerTickCallback(uint8_t endpoint); /** @brief RSSI Location Cluster Anchor Node Announce * - * + * * * @param anchorNodeIeeeAddress Ver.: always * @param coordinate1 Ver.: always * @param coordinate2 Ver.: always * @param coordinate3 Ver.: always */ -bool emberAfRssiLocationClusterAnchorNodeAnnounceCallback(uint8_t* anchorNodeIeeeAddress, - int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3); +bool emberAfRssiLocationClusterAnchorNodeAnnounceCallback(uint8_t * anchorNodeIeeeAddress, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3); /** @brief RSSI Location Cluster Client Attribute Changed * * Client Attribute Changed @@ -4424,8 +4012,7 @@ bool emberAfRssiLocationClusterAnchorNodeAnnounceCallback(uint8_t* anchorNodeIee * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfRssiLocationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfRssiLocationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief RSSI Location Cluster Client Default Response * * This function is called when the client receives the default response from @@ -4435,9 +4022,7 @@ void emberAfRssiLocationClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfRssiLocationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfRssiLocationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief RSSI Location Cluster Client Init * * Client Init @@ -4451,11 +4036,10 @@ void emberAfRssiLocationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfRssiLocationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfRssiLocationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief RSSI Location Cluster Client Message Sent * @@ -4469,11 +4053,8 @@ void emberAfRssiLocationClusterClientManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfRssiLocationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfRssiLocationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief RSSI Location Cluster Client Pre Attribute Changed * @@ -4485,11 +4066,9 @@ void emberAfRssiLocationClusterClientMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfRssiLocationClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfRssiLocationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief RSSI Location Cluster Client Tick * * Client Tick @@ -4499,7 +4078,7 @@ EmberAfStatus emberAfRssiLocationClusterClientPreAttributeChangedCallback(uint8_ void emberAfRssiLocationClusterClientTickCallback(uint8_t endpoint); /** @brief RSSI Location Cluster Compact Location Data Notification * - * + * * * @param locationType Ver.: always * @param coordinate1 Ver.: always @@ -4508,15 +4087,12 @@ void emberAfRssiLocationClusterClientTickCallback(uint8_t endpoint); * @param qualityMeasure Ver.: always * @param locationAge Ver.: always */ -bool emberAfRssiLocationClusterCompactLocationDataNotificationCallback(uint8_t locationType, - int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3, - uint8_t qualityMeasure, - uint16_t locationAge); +bool emberAfRssiLocationClusterCompactLocationDataNotificationCallback(uint8_t locationType, int16_t coordinate1, + int16_t coordinate2, int16_t coordinate3, + uint8_t qualityMeasure, uint16_t locationAge); /** @brief RSSI Location Cluster Device Configuration Response * - * + * * * @param status Ver.: always * @param power Ver.: always @@ -4525,33 +4101,28 @@ bool emberAfRssiLocationClusterCompactLocationDataNotificationCallback(uint8_t l * @param numberRssiMeasurements Ver.: always * @param reportingPeriod Ver.: always */ -bool emberAfRssiLocationClusterDeviceConfigurationResponseCallback(uint8_t status, - int16_t power, - uint16_t pathLossExponent, - uint16_t calculationPeriod, - uint8_t numberRssiMeasurements, - uint16_t reportingPeriod); +bool emberAfRssiLocationClusterDeviceConfigurationResponseCallback(uint8_t status, int16_t power, uint16_t pathLossExponent, + uint16_t calculationPeriod, uint8_t numberRssiMeasurements, + uint16_t reportingPeriod); /** @brief RSSI Location Cluster Get Device Configuration * - * + * * * @param targetAddress Ver.: always */ -bool emberAfRssiLocationClusterGetDeviceConfigurationCallback(uint8_t* targetAddress); +bool emberAfRssiLocationClusterGetDeviceConfigurationCallback(uint8_t * targetAddress); /** @brief RSSI Location Cluster Get Location Data * - * + * * * @param flags Ver.: always * @param numberResponses Ver.: always * @param targetAddress Ver.: always */ -bool emberAfRssiLocationClusterGetLocationDataCallback(uint8_t flags, - uint8_t numberResponses, - uint8_t* targetAddress); +bool emberAfRssiLocationClusterGetLocationDataCallback(uint8_t flags, uint8_t numberResponses, uint8_t * targetAddress); /** @brief RSSI Location Cluster Location Data Notification * - * + * * * @param locationType Ver.: always * @param coordinate1 Ver.: always @@ -4563,18 +4134,13 @@ bool emberAfRssiLocationClusterGetLocationDataCallback(uint8_t flags, * @param qualityMeasure Ver.: always * @param locationAge Ver.: always */ -bool emberAfRssiLocationClusterLocationDataNotificationCallback(uint8_t locationType, - int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3, - int16_t power, - uint16_t pathLossExponent, - uint8_t locationMethod, - uint8_t qualityMeasure, - uint16_t locationAge); +bool emberAfRssiLocationClusterLocationDataNotificationCallback(uint8_t locationType, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3, int16_t power, uint16_t pathLossExponent, + uint8_t locationMethod, uint8_t qualityMeasure, + uint16_t locationAge); /** @brief RSSI Location Cluster Location Data Response * - * + * * * @param status Ver.: always * @param locationType Ver.: always @@ -4587,50 +4153,43 @@ bool emberAfRssiLocationClusterLocationDataNotificationCallback(uint8_t location * @param qualityMeasure Ver.: always * @param locationAge Ver.: always */ -bool emberAfRssiLocationClusterLocationDataResponseCallback(uint8_t status, - uint8_t locationType, - int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3, - int16_t power, - uint16_t pathLossExponent, - uint8_t locationMethod, - uint8_t qualityMeasure, - uint16_t locationAge); +bool emberAfRssiLocationClusterLocationDataResponseCallback(uint8_t status, uint8_t locationType, int16_t coordinate1, + int16_t coordinate2, int16_t coordinate3, int16_t power, + uint16_t pathLossExponent, uint8_t locationMethod, + uint8_t qualityMeasure, uint16_t locationAge); /** @brief RSSI Location Cluster Report Rssi Measurements * - * + * * * @param measuringDevice Ver.: always * @param neighbors Ver.: always * @param neighborsInfo Ver.: always */ -bool emberAfRssiLocationClusterReportRssiMeasurementsCallback(uint8_t* measuringDevice, - uint8_t neighbors, - uint8_t* neighborsInfo); +bool emberAfRssiLocationClusterReportRssiMeasurementsCallback(uint8_t * measuringDevice, uint8_t neighbors, + uint8_t * neighborsInfo); /** @brief RSSI Location Cluster Request Own Location * - * + * * * @param blindNode Ver.: always */ -bool emberAfRssiLocationClusterRequestOwnLocationCallback(uint8_t* blindNode); +bool emberAfRssiLocationClusterRequestOwnLocationCallback(uint8_t * blindNode); /** @brief RSSI Location Cluster Rssi Ping * - * + * * * @param locationType Ver.: always */ bool emberAfRssiLocationClusterRssiPingCallback(uint8_t locationType); /** @brief RSSI Location Cluster Rssi Request * - * + * * */ bool emberAfRssiLocationClusterRssiRequestCallback(void); /** @brief RSSI Location Cluster Rssi Response * - * + * * * @param replyingDevice Ver.: always * @param coordinate1 Ver.: always @@ -4639,23 +4198,18 @@ bool emberAfRssiLocationClusterRssiRequestCallback(void); * @param rssi Ver.: always * @param numberRssiMeasurements Ver.: always */ -bool emberAfRssiLocationClusterRssiResponseCallback(uint8_t* replyingDevice, - int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3, - int8_t rssi, - uint8_t numberRssiMeasurements); +bool emberAfRssiLocationClusterRssiResponseCallback(uint8_t * replyingDevice, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3, int8_t rssi, uint8_t numberRssiMeasurements); /** @brief RSSI Location Cluster Send Pings * - * + * * * @param targetAddress Ver.: always * @param numberRssiMeasurements Ver.: always * @param calculationPeriod Ver.: always */ -bool emberAfRssiLocationClusterSendPingsCallback(uint8_t* targetAddress, - uint8_t numberRssiMeasurements, - uint16_t calculationPeriod); +bool emberAfRssiLocationClusterSendPingsCallback(uint8_t * targetAddress, uint8_t numberRssiMeasurements, + uint16_t calculationPeriod); /** @brief RSSI Location Cluster Server Attribute Changed * * Server Attribute Changed @@ -4663,8 +4217,7 @@ bool emberAfRssiLocationClusterSendPingsCallback(uint8_t* targetAddress, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfRssiLocationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfRssiLocationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief RSSI Location Cluster Server Default Response * * This function is called when the server receives the default response from @@ -4674,9 +4227,7 @@ void emberAfRssiLocationClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfRssiLocationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfRssiLocationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief RSSI Location Cluster Server Init * * Server Init @@ -4690,11 +4241,10 @@ void emberAfRssiLocationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfRssiLocationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfRssiLocationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief RSSI Location Cluster Server Message Sent * @@ -4708,11 +4258,8 @@ void emberAfRssiLocationClusterServerManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfRssiLocationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfRssiLocationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief RSSI Location Cluster Server Pre Attribute Changed * @@ -4724,11 +4271,9 @@ void emberAfRssiLocationClusterServerMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfRssiLocationClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfRssiLocationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief RSSI Location Cluster Server Tick * * Server Tick @@ -4738,7 +4283,7 @@ EmberAfStatus emberAfRssiLocationClusterServerPreAttributeChangedCallback(uint8_ void emberAfRssiLocationClusterServerTickCallback(uint8_t endpoint); /** @brief RSSI Location Cluster Set Absolute Location * - * + * * * @param coordinate1 Ver.: always * @param coordinate2 Ver.: always @@ -4746,14 +4291,11 @@ void emberAfRssiLocationClusterServerTickCallback(uint8_t endpoint); * @param power Ver.: always * @param pathLossExponent Ver.: always */ -bool emberAfRssiLocationClusterSetAbsoluteLocationCallback(int16_t coordinate1, - int16_t coordinate2, - int16_t coordinate3, - int16_t power, - uint16_t pathLossExponent); +bool emberAfRssiLocationClusterSetAbsoluteLocationCallback(int16_t coordinate1, int16_t coordinate2, int16_t coordinate3, + int16_t power, uint16_t pathLossExponent); /** @brief RSSI Location Cluster Set Device Configuration * - * + * * * @param power Ver.: always * @param pathLossExponent Ver.: always @@ -4761,11 +4303,8 @@ bool emberAfRssiLocationClusterSetAbsoluteLocationCallback(int16_t coordinate1, * @param numberRssiMeasurements Ver.: always * @param reportingPeriod Ver.: always */ -bool emberAfRssiLocationClusterSetDeviceConfigurationCallback(int16_t power, - uint16_t pathLossExponent, - uint16_t calculationPeriod, - uint8_t numberRssiMeasurements, - uint16_t reportingPeriod); +bool emberAfRssiLocationClusterSetDeviceConfigurationCallback(int16_t power, uint16_t pathLossExponent, uint16_t calculationPeriod, + uint8_t numberRssiMeasurements, uint16_t reportingPeriod); /** @} END RSSI Location Cluster Callbacks */ @@ -4779,8 +4318,7 @@ bool emberAfRssiLocationClusterSetDeviceConfigurationCallback(int16_t power, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBinaryInputBasicClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBinaryInputBasicClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Binary Input (Basic) Cluster Client Default Response * * This function is called when the client receives the default response from @@ -4790,9 +4328,7 @@ void emberAfBinaryInputBasicClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBinaryInputBasicClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBinaryInputBasicClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Binary Input (Basic) Cluster Client Init * * Client Init @@ -4806,7 +4342,7 @@ void emberAfBinaryInputBasicClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBinaryInputBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -4824,11 +4360,8 @@ void emberAfBinaryInputBasicClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBinaryInputBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBinaryInputBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Binary Input (Basic) Cluster Client Pre Attribute Changed * @@ -4840,11 +4373,9 @@ void emberAfBinaryInputBasicClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBinaryInputBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBinaryInputBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Binary Input (Basic) Cluster Client Tick * * Client Tick @@ -4859,8 +4390,7 @@ void emberAfBinaryInputBasicClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Binary Input (Basic) Cluster Server Default Response * * This function is called when the server receives the default response from @@ -4870,9 +4400,7 @@ void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBinaryInputBasicClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBinaryInputBasicClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Binary Input (Basic) Cluster Server Init * * Server Init @@ -4886,7 +4414,7 @@ void emberAfBinaryInputBasicClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBinaryInputBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -4904,11 +4432,8 @@ void emberAfBinaryInputBasicClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBinaryInputBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBinaryInputBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Binary Input (Basic) Cluster Server Pre Attribute Changed * @@ -4920,11 +4445,9 @@ void emberAfBinaryInputBasicClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBinaryInputBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBinaryInputBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Binary Input (Basic) Cluster Server Tick * * Server Tick @@ -4945,8 +4468,7 @@ void emberAfBinaryInputBasicClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Commissioning Cluster Client Default Response * * This function is called when the client receives the default response from @@ -4956,9 +4478,7 @@ void emberAfCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Commissioning Cluster Client Init * * Client Init @@ -4972,11 +4492,10 @@ void emberAfCommissioningClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Commissioning Cluster Client Message Sent * @@ -4990,11 +4509,8 @@ void emberAfCommissioningClusterClientManufacturerSpecificAttributeChangedCallba * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Commissioning Cluster Client Pre Attribute Changed * @@ -5006,11 +4522,9 @@ void emberAfCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageTy * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Commissioning Cluster Client Tick * * Client Tick @@ -5020,66 +4534,61 @@ EmberAfStatus emberAfCommissioningClusterClientPreAttributeChangedCallback(uint8 void emberAfCommissioningClusterClientTickCallback(uint8_t endpoint); /** @brief Commissioning Cluster Reset Startup Parameters * - * + * * * @param options Ver.: always * @param index Ver.: always */ -bool emberAfCommissioningClusterResetStartupParametersCallback(uint8_t options, - uint8_t index); +bool emberAfCommissioningClusterResetStartupParametersCallback(uint8_t options, uint8_t index); /** @brief Commissioning Cluster Reset Startup Parameters Response * - * + * * * @param status Ver.: always */ bool emberAfCommissioningClusterResetStartupParametersResponseCallback(uint8_t status); /** @brief Commissioning Cluster Restart Device * - * + * * * @param options Ver.: always * @param delay Ver.: always * @param jitter Ver.: always */ -bool emberAfCommissioningClusterRestartDeviceCallback(uint8_t options, - uint8_t delay, - uint8_t jitter); +bool emberAfCommissioningClusterRestartDeviceCallback(uint8_t options, uint8_t delay, uint8_t jitter); /** @brief Commissioning Cluster Restart Device Response * - * + * * * @param status Ver.: always */ bool emberAfCommissioningClusterRestartDeviceResponseCallback(uint8_t status); /** @brief Commissioning Cluster Restore Startup Parameters * - * + * * * @param options Ver.: always * @param index Ver.: always */ -bool emberAfCommissioningClusterRestoreStartupParametersCallback(uint8_t options, - uint8_t index); +bool emberAfCommissioningClusterRestoreStartupParametersCallback(uint8_t options, uint8_t index); /** @brief Commissioning Cluster Restore Startup Parameters Response * - * + * * * @param status Ver.: always */ bool emberAfCommissioningClusterRestoreStartupParametersResponseCallback(uint8_t status); /** @brief Commissioning Cluster Save Startup Parameters * - * + * * * @param options Ver.: always * @param index Ver.: always */ -bool emberAfCommissioningClusterSaveStartupParametersCallback(uint8_t options, - uint8_t index); +bool emberAfCommissioningClusterSaveStartupParametersCallback(uint8_t options, uint8_t index); /** @brief Commissioning Cluster Save Startup Parameters Response * - * + * * * @param status Ver.: always */ @@ -5091,8 +4600,7 @@ bool emberAfCommissioningClusterSaveStartupParametersResponseCallback(uint8_t st * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Commissioning Cluster Server Default Response * * This function is called when the server receives the default response from @@ -5102,9 +4610,7 @@ void emberAfCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Commissioning Cluster Server Init * * Server Init @@ -5118,11 +4624,10 @@ void emberAfCommissioningClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Commissioning Cluster Server Message Sent * @@ -5136,11 +4641,8 @@ void emberAfCommissioningClusterServerManufacturerSpecificAttributeChangedCallba * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Commissioning Cluster Server Pre Attribute Changed * @@ -5152,11 +4654,9 @@ void emberAfCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageTy * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Commissioning Cluster Server Tick * * Server Tick @@ -5177,8 +4677,7 @@ void emberAfCommissioningClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPartitionClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPartitionClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Partition Cluster Client Default Response * * This function is called when the client receives the default response from @@ -5188,9 +4687,7 @@ void emberAfPartitionClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPartitionClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPartitionClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Partition Cluster Client Init * * Client Init @@ -5204,11 +4701,10 @@ void emberAfPartitionClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPartitionClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPartitionClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Partition Cluster Client Message Sent * @@ -5222,11 +4718,8 @@ void emberAfPartitionClusterClientManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPartitionClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPartitionClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Partition Cluster Client Pre Attribute Changed * @@ -5238,11 +4731,9 @@ void emberAfPartitionClusterClientMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPartitionClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPartitionClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Partition Cluster Client Tick * * Client Tick @@ -5252,31 +4743,28 @@ EmberAfStatus emberAfPartitionClusterClientPreAttributeChangedCallback(uint8_t e void emberAfPartitionClusterClientTickCallback(uint8_t endpoint); /** @brief Partition Cluster Multiple Ack * - * + * * * @param ackOptions Ver.: always * @param firstFrameIdAndNackList Ver.: always */ -bool emberAfPartitionClusterMultipleAckCallback(uint8_t ackOptions, - uint8_t* firstFrameIdAndNackList); +bool emberAfPartitionClusterMultipleAckCallback(uint8_t ackOptions, uint8_t * firstFrameIdAndNackList); /** @brief Partition Cluster Read Handshake Param * - * + * * * @param partitionedClusterId Ver.: always * @param attributeList Ver.: always */ -bool emberAfPartitionClusterReadHandshakeParamCallback(uint16_t partitionedClusterId, - uint8_t* attributeList); +bool emberAfPartitionClusterReadHandshakeParamCallback(uint16_t partitionedClusterId, uint8_t * attributeList); /** @brief Partition Cluster Read Handshake Param Response * - * + * * * @param partitionedClusterId Ver.: always * @param readAttributeStatusRecords Ver.: always */ -bool emberAfPartitionClusterReadHandshakeParamResponseCallback(uint16_t partitionedClusterId, - uint8_t* readAttributeStatusRecords); +bool emberAfPartitionClusterReadHandshakeParamResponseCallback(uint16_t partitionedClusterId, uint8_t * readAttributeStatusRecords); /** @brief Partition Cluster Server Attribute Changed * * Server Attribute Changed @@ -5284,8 +4772,7 @@ bool emberAfPartitionClusterReadHandshakeParamResponseCallback(uint16_t partitio * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPartitionClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPartitionClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Partition Cluster Server Default Response * * This function is called when the server receives the default response from @@ -5295,9 +4782,7 @@ void emberAfPartitionClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPartitionClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPartitionClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Partition Cluster Server Init * * Server Init @@ -5311,11 +4796,10 @@ void emberAfPartitionClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPartitionClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPartitionClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Partition Cluster Server Message Sent * @@ -5329,11 +4813,8 @@ void emberAfPartitionClusterServerManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPartitionClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPartitionClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Partition Cluster Server Pre Attribute Changed * @@ -5345,11 +4826,9 @@ void emberAfPartitionClusterServerMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPartitionClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPartitionClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Partition Cluster Server Tick * * Server Tick @@ -5359,22 +4838,20 @@ EmberAfStatus emberAfPartitionClusterServerPreAttributeChangedCallback(uint8_t e void emberAfPartitionClusterServerTickCallback(uint8_t endpoint); /** @brief Partition Cluster Transfer Partitioned Frame * - * + * * * @param fragmentationOptions Ver.: always * @param partitionedIndicatorAndFrame Ver.: always */ -bool emberAfPartitionClusterTransferPartitionedFrameCallback(uint8_t fragmentationOptions, - uint8_t* partitionedIndicatorAndFrame); +bool emberAfPartitionClusterTransferPartitionedFrameCallback(uint8_t fragmentationOptions, uint8_t * partitionedIndicatorAndFrame); /** @brief Partition Cluster Write Handshake Param * - * + * * * @param partitionedClusterId Ver.: always * @param writeAttributeRecords Ver.: always */ -bool emberAfPartitionClusterWriteHandshakeParamCallback(uint16_t partitionedClusterId, - uint8_t* writeAttributeRecords); +bool emberAfPartitionClusterWriteHandshakeParamCallback(uint16_t partitionedClusterId, uint8_t * writeAttributeRecords); /** @} END Partition Cluster Callbacks */ @@ -5388,8 +4865,7 @@ bool emberAfPartitionClusterWriteHandshakeParamCallback(uint16_t partitionedClus * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOtaBootloadClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOtaBootloadClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Over the Air Bootloading Cluster Client Default Response * * This function is called when the client receives the default response from @@ -5399,9 +4875,7 @@ void emberAfOtaBootloadClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOtaBootloadClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOtaBootloadClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Over the Air Bootloading Cluster Client Init * * Client Init @@ -5415,11 +4889,10 @@ void emberAfOtaBootloadClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfOtaBootloadClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfOtaBootloadClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Over the Air Bootloading Cluster Client Message Sent * @@ -5433,11 +4906,8 @@ void emberAfOtaBootloadClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOtaBootloadClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOtaBootloadClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Over the Air Bootloading Cluster Client Pre Attribute Changed * @@ -5449,11 +4919,9 @@ void emberAfOtaBootloadClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOtaBootloadClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOtaBootloadClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Over the Air Bootloading Cluster Client Tick * * Client Tick @@ -5468,8 +4936,7 @@ void emberAfOtaBootloadClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOtaBootloadClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOtaBootloadClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Over the Air Bootloading Cluster Server Default Response * * This function is called when the server receives the default response from @@ -5479,9 +4946,7 @@ void emberAfOtaBootloadClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOtaBootloadClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOtaBootloadClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Over the Air Bootloading Cluster Server Init * * Server Init @@ -5495,11 +4960,10 @@ void emberAfOtaBootloadClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfOtaBootloadClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfOtaBootloadClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Over the Air Bootloading Cluster Server Message Sent * @@ -5513,11 +4977,8 @@ void emberAfOtaBootloadClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOtaBootloadClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOtaBootloadClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Over the Air Bootloading Cluster Server Pre Attribute Changed * @@ -5529,11 +4990,9 @@ void emberAfOtaBootloadClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOtaBootloadClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOtaBootloadClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Over the Air Bootloading Cluster Server Tick * * Server Tick @@ -5554,8 +5013,7 @@ void emberAfOtaBootloadClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPowerProfileClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPowerProfileClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Power Profile Cluster Client Default Response * * This function is called when the client receives the default response from @@ -5565,9 +5023,7 @@ void emberAfPowerProfileClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPowerProfileClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPowerProfileClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Power Profile Cluster Client Init * * Client Init @@ -5581,11 +5037,10 @@ void emberAfPowerProfileClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPowerProfileClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPowerProfileClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Power Profile Cluster Client Message Sent * @@ -5599,11 +5054,8 @@ void emberAfPowerProfileClusterClientManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPowerProfileClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPowerProfileClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Power Profile Cluster Client Pre Attribute Changed * @@ -5615,11 +5067,9 @@ void emberAfPowerProfileClusterClientMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPowerProfileClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPowerProfileClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Power Profile Cluster Client Tick * * Client Tick @@ -5629,209 +5079,191 @@ EmberAfStatus emberAfPowerProfileClusterClientPreAttributeChangedCallback(uint8_ void emberAfPowerProfileClusterClientTickCallback(uint8_t endpoint); /** @brief Power Profile Cluster Energy Phases Schedule Notification * - * + * * * @param powerProfileId Ver.: always * @param numOfScheduledPhases Ver.: always * @param scheduledPhases Ver.: always */ -bool emberAfPowerProfileClusterEnergyPhasesScheduleNotificationCallback(uint8_t powerProfileId, - uint8_t numOfScheduledPhases, - uint8_t* scheduledPhases); +bool emberAfPowerProfileClusterEnergyPhasesScheduleNotificationCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); /** @brief Power Profile Cluster Energy Phases Schedule Request * - * + * * * @param powerProfileId Ver.: always */ bool emberAfPowerProfileClusterEnergyPhasesScheduleRequestCallback(uint8_t powerProfileId); /** @brief Power Profile Cluster Energy Phases Schedule Response * - * + * * * @param powerProfileId Ver.: always * @param numOfScheduledPhases Ver.: always * @param scheduledPhases Ver.: always */ -bool emberAfPowerProfileClusterEnergyPhasesScheduleResponseCallback(uint8_t powerProfileId, - uint8_t numOfScheduledPhases, - uint8_t* scheduledPhases); +bool emberAfPowerProfileClusterEnergyPhasesScheduleResponseCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); /** @brief Power Profile Cluster Energy Phases Schedule State Notification * - * + * * * @param powerProfileId Ver.: always * @param numOfScheduledPhases Ver.: always * @param scheduledPhases Ver.: always */ -bool emberAfPowerProfileClusterEnergyPhasesScheduleStateNotificationCallback(uint8_t powerProfileId, - uint8_t numOfScheduledPhases, - uint8_t* scheduledPhases); +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateNotificationCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); /** @brief Power Profile Cluster Energy Phases Schedule State Request * - * + * * * @param powerProfileId Ver.: always */ bool emberAfPowerProfileClusterEnergyPhasesScheduleStateRequestCallback(uint8_t powerProfileId); /** @brief Power Profile Cluster Energy Phases Schedule State Response * - * + * * * @param powerProfileId Ver.: always * @param numOfScheduledPhases Ver.: always * @param scheduledPhases Ver.: always */ -bool emberAfPowerProfileClusterEnergyPhasesScheduleStateResponseCallback(uint8_t powerProfileId, - uint8_t numOfScheduledPhases, - uint8_t* scheduledPhases); +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateResponseCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); /** @brief Power Profile Cluster Get Overall Schedule Price * - * + * * */ bool emberAfPowerProfileClusterGetOverallSchedulePriceCallback(void); /** @brief Power Profile Cluster Get Overall Schedule Price Response * - * + * * * @param currency Ver.: always * @param price Ver.: always * @param priceTrailingDigit Ver.: always */ -bool emberAfPowerProfileClusterGetOverallSchedulePriceResponseCallback(uint16_t currency, - uint32_t price, - uint8_t priceTrailingDigit); +bool emberAfPowerProfileClusterGetOverallSchedulePriceResponseCallback(uint16_t currency, uint32_t price, + uint8_t priceTrailingDigit); /** @brief Power Profile Cluster Get Power Profile Price * - * + * * * @param powerProfileId Ver.: always */ bool emberAfPowerProfileClusterGetPowerProfilePriceCallback(uint8_t powerProfileId); /** @brief Power Profile Cluster Get Power Profile Price Extended * - * + * * * @param options Ver.: always * @param powerProfileId Ver.: always * @param powerProfileStartTime Ver.: always */ -bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedCallback(uint8_t options, - uint8_t powerProfileId, - uint16_t powerProfileStartTime); +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedCallback(uint8_t options, uint8_t powerProfileId, + uint16_t powerProfileStartTime); /** @brief Power Profile Cluster Get Power Profile Price Extended Response * - * + * * * @param powerProfileId Ver.: always * @param currency Ver.: always * @param price Ver.: always * @param priceTrailingDigit Ver.: always */ -bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedResponseCallback(uint8_t powerProfileId, - uint16_t currency, - uint32_t price, - uint8_t priceTrailingDigit); +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedResponseCallback(uint8_t powerProfileId, uint16_t currency, + uint32_t price, uint8_t priceTrailingDigit); /** @brief Power Profile Cluster Get Power Profile Price Response * - * + * * * @param powerProfileId Ver.: always * @param currency Ver.: always * @param price Ver.: always * @param priceTrailingDigit Ver.: always */ -bool emberAfPowerProfileClusterGetPowerProfilePriceResponseCallback(uint8_t powerProfileId, - uint16_t currency, - uint32_t price, - uint8_t priceTrailingDigit); +bool emberAfPowerProfileClusterGetPowerProfilePriceResponseCallback(uint8_t powerProfileId, uint16_t currency, uint32_t price, + uint8_t priceTrailingDigit); /** @brief Power Profile Cluster Power Profile Notification * - * + * * * @param totalProfileNum Ver.: always * @param powerProfileId Ver.: always * @param numOfTransferredPhases Ver.: always * @param transferredPhases Ver.: always */ -bool emberAfPowerProfileClusterPowerProfileNotificationCallback(uint8_t totalProfileNum, - uint8_t powerProfileId, - uint8_t numOfTransferredPhases, - uint8_t* transferredPhases); +bool emberAfPowerProfileClusterPowerProfileNotificationCallback(uint8_t totalProfileNum, uint8_t powerProfileId, + uint8_t numOfTransferredPhases, uint8_t * transferredPhases); /** @brief Power Profile Cluster Power Profile Request * - * + * * * @param powerProfileId Ver.: always */ bool emberAfPowerProfileClusterPowerProfileRequestCallback(uint8_t powerProfileId); /** @brief Power Profile Cluster Power Profile Response * - * + * * * @param totalProfileNum Ver.: always * @param powerProfileId Ver.: always * @param numOfTransferredPhases Ver.: always * @param transferredPhases Ver.: always */ -bool emberAfPowerProfileClusterPowerProfileResponseCallback(uint8_t totalProfileNum, - uint8_t powerProfileId, - uint8_t numOfTransferredPhases, - uint8_t* transferredPhases); +bool emberAfPowerProfileClusterPowerProfileResponseCallback(uint8_t totalProfileNum, uint8_t powerProfileId, + uint8_t numOfTransferredPhases, uint8_t * transferredPhases); /** @brief Power Profile Cluster Power Profile Schedule Constraints Notification * - * + * * * @param powerProfileId Ver.: always * @param startAfter Ver.: always * @param stopBefore Ver.: always */ -bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsNotificationCallback(uint8_t powerProfileId, - uint16_t startAfter, - uint16_t stopBefore); +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsNotificationCallback(uint8_t powerProfileId, uint16_t startAfter, + uint16_t stopBefore); /** @brief Power Profile Cluster Power Profile Schedule Constraints Request * - * + * * * @param powerProfileId Ver.: always */ bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsRequestCallback(uint8_t powerProfileId); /** @brief Power Profile Cluster Power Profile Schedule Constraints Response * - * + * * * @param powerProfileId Ver.: always * @param startAfter Ver.: always * @param stopBefore Ver.: always */ -bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsResponseCallback(uint8_t powerProfileId, - uint16_t startAfter, - uint16_t stopBefore); +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsResponseCallback(uint8_t powerProfileId, uint16_t startAfter, + uint16_t stopBefore); /** @brief Power Profile Cluster Power Profile State Request * - * + * * */ bool emberAfPowerProfileClusterPowerProfileStateRequestCallback(void); /** @brief Power Profile Cluster Power Profile State Response * - * + * * * @param powerProfileCount Ver.: always * @param powerProfileRecords Ver.: always */ -bool emberAfPowerProfileClusterPowerProfileStateResponseCallback(uint8_t powerProfileCount, - uint8_t* powerProfileRecords); +bool emberAfPowerProfileClusterPowerProfileStateResponseCallback(uint8_t powerProfileCount, uint8_t * powerProfileRecords); /** @brief Power Profile Cluster Power Profiles State Notification * - * + * * * @param powerProfileCount Ver.: always * @param powerProfileRecords Ver.: always */ -bool emberAfPowerProfileClusterPowerProfilesStateNotificationCallback(uint8_t powerProfileCount, - uint8_t* powerProfileRecords); +bool emberAfPowerProfileClusterPowerProfilesStateNotificationCallback(uint8_t powerProfileCount, uint8_t * powerProfileRecords); /** @brief Power Profile Cluster Server Attribute Changed * * Server Attribute Changed @@ -5839,8 +5271,7 @@ bool emberAfPowerProfileClusterPowerProfilesStateNotificationCallback(uint8_t po * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPowerProfileClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPowerProfileClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Power Profile Cluster Server Default Response * * This function is called when the server receives the default response from @@ -5850,9 +5281,7 @@ void emberAfPowerProfileClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPowerProfileClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPowerProfileClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Power Profile Cluster Server Init * * Server Init @@ -5866,11 +5295,10 @@ void emberAfPowerProfileClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPowerProfileClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPowerProfileClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Power Profile Cluster Server Message Sent * @@ -5884,11 +5312,8 @@ void emberAfPowerProfileClusterServerManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPowerProfileClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPowerProfileClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Power Profile Cluster Server Pre Attribute Changed * @@ -5900,11 +5325,9 @@ void emberAfPowerProfileClusterServerMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPowerProfileClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPowerProfileClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Power Profile Cluster Server Tick * * Server Tick @@ -5925,8 +5348,7 @@ void emberAfPowerProfileClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -5936,9 +5358,7 @@ void emberAfApplianceControlClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Control Cluster Client Init * * Client Init @@ -5952,7 +5372,7 @@ void emberAfApplianceControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -5970,11 +5390,8 @@ void emberAfApplianceControlClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Control Cluster Client Pre Attribute Changed * @@ -5986,11 +5403,9 @@ void emberAfApplianceControlClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfApplianceControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfApplianceControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Appliance Control Cluster Client Tick * * Client Tick @@ -6000,26 +5415,26 @@ EmberAfStatus emberAfApplianceControlClusterClientPreAttributeChangedCallback(ui void emberAfApplianceControlClusterClientTickCallback(uint8_t endpoint); /** @brief Appliance Control Cluster Execution Of A Command * - * + * * * @param commandId Ver.: always */ bool emberAfApplianceControlClusterExecutionOfACommandCallback(uint8_t commandId); /** @brief Appliance Control Cluster Overload Pause * - * + * * */ bool emberAfApplianceControlClusterOverloadPauseCallback(void); /** @brief Appliance Control Cluster Overload Pause Resume * - * + * * */ bool emberAfApplianceControlClusterOverloadPauseResumeCallback(void); /** @brief Appliance Control Cluster Overload Warning * - * + * * * @param warningEvent Ver.: always */ @@ -6031,8 +5446,7 @@ bool emberAfApplianceControlClusterOverloadWarningCallback(uint8_t warningEvent) * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -6042,9 +5456,7 @@ void emberAfApplianceControlClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Control Cluster Server Init * * Server Init @@ -6058,7 +5470,7 @@ void emberAfApplianceControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -6076,11 +5488,8 @@ void emberAfApplianceControlClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Control Cluster Server Pre Attribute Changed * @@ -6092,11 +5501,9 @@ void emberAfApplianceControlClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfApplianceControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfApplianceControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Appliance Control Cluster Server Tick * * Server Tick @@ -6106,43 +5513,40 @@ EmberAfStatus emberAfApplianceControlClusterServerPreAttributeChangedCallback(ui void emberAfApplianceControlClusterServerTickCallback(uint8_t endpoint); /** @brief Appliance Control Cluster Signal State * - * + * * */ bool emberAfApplianceControlClusterSignalStateCallback(void); /** @brief Appliance Control Cluster Signal State Notification * - * + * * * @param applianceStatus Ver.: always * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always * @param applianceStatus2 Ver.: always */ bool emberAfApplianceControlClusterSignalStateNotificationCallback(uint8_t applianceStatus, - uint8_t remoteEnableFlagsAndDeviceStatus2, - uint32_t applianceStatus2); + uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); /** @brief Appliance Control Cluster Signal State Response * - * + * * * @param applianceStatus Ver.: always * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always * @param applianceStatus2 Ver.: always */ -bool emberAfApplianceControlClusterSignalStateResponseCallback(uint8_t applianceStatus, - uint8_t remoteEnableFlagsAndDeviceStatus2, - uint32_t applianceStatus2); +bool emberAfApplianceControlClusterSignalStateResponseCallback(uint8_t applianceStatus, uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); /** @brief Appliance Control Cluster Write Functions * - * + * * * @param functionId Ver.: always * @param functionDataType Ver.: always * @param functionData Ver.: always */ -bool emberAfApplianceControlClusterWriteFunctionsCallback(uint16_t functionId, - uint8_t functionDataType, - uint8_t* functionData); +bool emberAfApplianceControlClusterWriteFunctionsCallback(uint16_t functionId, uint8_t functionDataType, uint8_t * functionData); /** @} END Appliance Control Cluster Callbacks */ @@ -6151,19 +5555,18 @@ bool emberAfApplianceControlClusterWriteFunctionsCallback(uint16_t functionId, /** @brief Poll Control Cluster Check In * - * + * * */ bool emberAfPollControlClusterCheckInCallback(void); /** @brief Poll Control Cluster Check In Response * - * + * * * @param startFastPolling Ver.: always * @param fastPollTimeout Ver.: always */ -bool emberAfPollControlClusterCheckInResponseCallback(uint8_t startFastPolling, - uint16_t fastPollTimeout); +bool emberAfPollControlClusterCheckInResponseCallback(uint8_t startFastPolling, uint16_t fastPollTimeout); /** @brief Poll Control Cluster Client Attribute Changed * * Client Attribute Changed @@ -6171,8 +5574,7 @@ bool emberAfPollControlClusterCheckInResponseCallback(uint8_t startFastPolling, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPollControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPollControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Poll Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -6182,9 +5584,7 @@ void emberAfPollControlClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPollControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPollControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Poll Control Cluster Client Init * * Client Init @@ -6198,11 +5598,10 @@ void emberAfPollControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPollControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPollControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Poll Control Cluster Client Message Sent * @@ -6216,11 +5615,8 @@ void emberAfPollControlClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPollControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPollControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Poll Control Cluster Client Pre Attribute Changed * @@ -6232,11 +5628,9 @@ void emberAfPollControlClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPollControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPollControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Poll Control Cluster Client Tick * * Client Tick @@ -6246,7 +5640,7 @@ EmberAfStatus emberAfPollControlClusterClientPreAttributeChangedCallback(uint8_t void emberAfPollControlClusterClientTickCallback(uint8_t endpoint); /** @brief Poll Control Cluster Fast Poll Stop * - * + * * */ bool emberAfPollControlClusterFastPollStopCallback(void); @@ -6257,8 +5651,7 @@ bool emberAfPollControlClusterFastPollStopCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Poll Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -6268,9 +5661,7 @@ void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPollControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPollControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Poll Control Cluster Server Init * * Server Init @@ -6284,11 +5675,10 @@ void emberAfPollControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPollControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPollControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Poll Control Cluster Server Message Sent * @@ -6302,11 +5692,8 @@ void emberAfPollControlClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPollControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPollControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Poll Control Cluster Server Pre Attribute Changed * @@ -6318,11 +5705,9 @@ void emberAfPollControlClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Poll Control Cluster Server Tick * * Server Tick @@ -6332,14 +5717,14 @@ EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t void emberAfPollControlClusterServerTickCallback(uint8_t endpoint); /** @brief Poll Control Cluster Set Long Poll Interval * - * + * * * @param newLongPollInterval Ver.: always */ bool emberAfPollControlClusterSetLongPollIntervalCallback(uint32_t newLongPollInterval); /** @brief Poll Control Cluster Set Short Poll Interval * - * + * * * @param newShortPollInterval Ver.: always */ @@ -6357,8 +5742,7 @@ bool emberAfPollControlClusterSetShortPollIntervalCallback(uint16_t newShortPoll * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGreenPowerClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGreenPowerClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Green Power Cluster Client Default Response * * This function is called when the client receives the default response from @@ -6368,9 +5752,7 @@ void emberAfGreenPowerClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGreenPowerClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGreenPowerClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Green Power Cluster Client Init * * Client Init @@ -6384,11 +5766,10 @@ void emberAfGreenPowerClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGreenPowerClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGreenPowerClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Green Power Cluster Client Message Sent * @@ -6402,11 +5783,8 @@ void emberAfGreenPowerClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGreenPowerClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGreenPowerClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Green Power Cluster Client Pre Attribute Changed * @@ -6418,11 +5796,9 @@ void emberAfGreenPowerClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGreenPowerClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGreenPowerClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Green Power Cluster Client Tick * * Client Tick @@ -6432,7 +5808,7 @@ EmberAfStatus emberAfGreenPowerClusterClientPreAttributeChangedCallback(uint8_t void emberAfGreenPowerClusterClientTickCallback(uint8_t endpoint); /** @brief Green Power Cluster Gp Commissioning Notification * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6445,19 +5821,13 @@ void emberAfGreenPowerClusterClientTickCallback(uint8_t endpoint); * @param gppLink Ver.: since gp-1.0-09-5499-24 * @param mic Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpCommissioningNotificationCallback(uint16_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint32_t gpdSecurityFrameCounter, - uint8_t gpdCommandId, - uint8_t* gpdCommandPayload, - uint16_t gppShortAddress, - uint8_t gppLink, - uint32_t mic); +bool emberAfGreenPowerClusterGpCommissioningNotificationCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, + uint8_t endpoint, uint32_t gpdSecurityFrameCounter, + uint8_t gpdCommandId, uint8_t * gpdCommandPayload, + uint16_t gppShortAddress, uint8_t gppLink, uint32_t mic); /** @brief Green Power Cluster Gp Notification * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6469,18 +5839,12 @@ bool emberAfGreenPowerClusterGpCommissioningNotificationCallback(uint16_t option * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 * @param gppDistance Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpNotificationCallback(uint16_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t gpdEndpoint, - uint32_t gpdSecurityFrameCounter, - uint8_t gpdCommandId, - uint8_t* gpdCommandPayload, - uint16_t gppShortAddress, - uint8_t gppDistance); +bool emberAfGreenPowerClusterGpNotificationCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t gpdEndpoint, + uint32_t gpdSecurityFrameCounter, uint8_t gpdCommandId, + uint8_t * gpdCommandPayload, uint16_t gppShortAddress, uint8_t gppDistance); /** @brief Green Power Cluster Gp Notification Response * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6488,14 +5852,11 @@ bool emberAfGreenPowerClusterGpNotificationCallback(uint16_t options, * @param endpoint Ver.: since gp-1.0-09-5499-24 * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpNotificationResponseCallback(uint8_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint32_t gpdSecurityFrameCounter); +bool emberAfGreenPowerClusterGpNotificationResponseCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint32_t gpdSecurityFrameCounter); /** @brief Green Power Cluster Gp Pairing * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6510,21 +5871,13 @@ bool emberAfGreenPowerClusterGpNotificationResponseCallback(uint8_t options, * @param assignedAlias Ver.: since gp-1.0-09-5499-24 * @param groupcastRadius Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpPairingCallback(uint32_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t* sinkIeeeAddress, - uint16_t sinkNwkAddress, - uint16_t sinkGroupId, - uint8_t deviceId, - uint32_t gpdSecurityFrameCounter, - uint8_t* gpdKey, - uint16_t assignedAlias, - uint8_t groupcastRadius); +bool emberAfGreenPowerClusterGpPairingCallback(uint32_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t * sinkIeeeAddress, uint16_t sinkNwkAddress, uint16_t sinkGroupId, + uint8_t deviceId, uint32_t gpdSecurityFrameCounter, uint8_t * gpdKey, + uint16_t assignedAlias, uint8_t groupcastRadius); /** @brief Green Power Cluster Gp Pairing Configuration * - * + * * * @param actions Ver.: since gp-1.0-09-5499-24 * @param options Ver.: since gp-1.0-09-5499-24 @@ -6556,62 +5909,36 @@ bool emberAfGreenPowerClusterGpPairingCallback(uint32_t options, * @param numberOfReports Ver.: always * @param reportDescriptor Ver.: always */ -bool emberAfGreenPowerClusterGpPairingConfigurationCallback(uint8_t actions, - uint16_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t deviceId, - uint8_t groupListCount, - uint8_t* groupList, - uint16_t gpdAssignedAlias, - uint8_t groupcastRadius, - uint8_t securityOptions, - uint32_t gpdSecurityFrameCounter, - uint8_t* gpdSecurityKey, - uint8_t numberOfPairedEndpoints, - uint8_t* pairedEndpoints, - uint8_t applicationInformation, - uint16_t manufacturerId, - uint16_t modeId, - uint8_t numberOfGpdCommands, - uint8_t* gpdCommandIdList, - uint8_t clusterIdListCount, - uint8_t* clusterListServer, - uint8_t* clusterListClient, - uint8_t switchInformationLength, - uint8_t switchConfiguration, - uint8_t currentContactStatus, - uint8_t totalNumberOfReports, - uint8_t numberOfReports, - uint8_t* reportDescriptor); +bool emberAfGreenPowerClusterGpPairingConfigurationCallback( + uint8_t actions, uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, uint8_t deviceId, + uint8_t groupListCount, uint8_t * groupList, uint16_t gpdAssignedAlias, uint8_t groupcastRadius, uint8_t securityOptions, + uint32_t gpdSecurityFrameCounter, uint8_t * gpdSecurityKey, uint8_t numberOfPairedEndpoints, uint8_t * pairedEndpoints, + uint8_t applicationInformation, uint16_t manufacturerId, uint16_t modeId, uint8_t numberOfGpdCommands, + uint8_t * gpdCommandIdList, uint8_t clusterIdListCount, uint8_t * clusterListServer, uint8_t * clusterListClient, + uint8_t switchInformationLength, uint8_t switchConfiguration, uint8_t currentContactStatus, uint8_t totalNumberOfReports, + uint8_t numberOfReports, uint8_t * reportDescriptor); /** @brief Green Power Cluster Gp Pairing Search * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 * @param gpdIeee Ver.: since gp-1.0-09-5499-24 * @param endpoint Ver.: always */ -bool emberAfGreenPowerClusterGpPairingSearchCallback(uint16_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint); +bool emberAfGreenPowerClusterGpPairingSearchCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint); /** @brief Green Power Cluster Gp Proxy Commissioning Mode * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param commissioningWindow Ver.: since gp-1.0-15-02014-011 * @param channel Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpProxyCommissioningModeCallback(uint8_t options, - uint16_t commissioningWindow, - uint8_t channel); +bool emberAfGreenPowerClusterGpProxyCommissioningModeCallback(uint8_t options, uint16_t commissioningWindow, uint8_t channel); /** @brief Green Power Cluster Gp Proxy Table Request * - * + * * * @param options Ver.: always * @param gpdSrcId Ver.: always @@ -6619,14 +5946,11 @@ bool emberAfGreenPowerClusterGpProxyCommissioningModeCallback(uint8_t options, * @param endpoint Ver.: always * @param index Ver.: always */ -bool emberAfGreenPowerClusterGpProxyTableRequestCallback(uint8_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t index); +bool emberAfGreenPowerClusterGpProxyTableRequestCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t index); /** @brief Green Power Cluster Gp Proxy Table Response * - * + * * * @param status Ver.: always * @param totalNumberOfNonEmptyProxyTableEntries Ver.: always @@ -6634,14 +5958,11 @@ bool emberAfGreenPowerClusterGpProxyTableRequestCallback(uint8_t options, * @param entriesCount Ver.: always * @param proxyTableEntries Ver.: always */ -bool emberAfGreenPowerClusterGpProxyTableResponseCallback(uint8_t status, - uint8_t totalNumberOfNonEmptyProxyTableEntries, - uint8_t startIndex, - uint8_t entriesCount, - uint8_t* proxyTableEntries); +bool emberAfGreenPowerClusterGpProxyTableResponseCallback(uint8_t status, uint8_t totalNumberOfNonEmptyProxyTableEntries, + uint8_t startIndex, uint8_t entriesCount, uint8_t * proxyTableEntries); /** @brief Green Power Cluster Gp Response * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param tempMasterShortAddress Ver.: since gp-1.0-09-5499-24 @@ -6652,30 +5973,23 @@ bool emberAfGreenPowerClusterGpProxyTableResponseCallback(uint8_t status, * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 * @param gpdCommandPayload Ver.: always */ -bool emberAfGreenPowerClusterGpResponseCallback(uint8_t options, - uint16_t tempMasterShortAddress, - uint8_t tempMasterTxChannel, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t gpdCommandId, - uint8_t* gpdCommandPayload); +bool emberAfGreenPowerClusterGpResponseCallback(uint8_t options, uint16_t tempMasterShortAddress, uint8_t tempMasterTxChannel, + uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, uint8_t gpdCommandId, + uint8_t * gpdCommandPayload); /** @brief Green Power Cluster Gp Sink Commissioning Mode * - * + * * * @param options Ver.: always * @param gpmAddrForSecurity Ver.: always * @param gpmAddrForPairing Ver.: always * @param sinkEndpoint Ver.: always */ -bool emberAfGreenPowerClusterGpSinkCommissioningModeCallback(uint8_t options, - uint16_t gpmAddrForSecurity, - uint16_t gpmAddrForPairing, - uint8_t sinkEndpoint); +bool emberAfGreenPowerClusterGpSinkCommissioningModeCallback(uint8_t options, uint16_t gpmAddrForSecurity, + uint16_t gpmAddrForPairing, uint8_t sinkEndpoint); /** @brief Green Power Cluster Gp Sink Table Request * - * + * * * @param options Ver.: always * @param gpdSrcId Ver.: always @@ -6683,14 +5997,11 @@ bool emberAfGreenPowerClusterGpSinkCommissioningModeCallback(uint8_t options, * @param endpoint Ver.: always * @param index Ver.: always */ -bool emberAfGreenPowerClusterGpSinkTableRequestCallback(uint8_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t index); +bool emberAfGreenPowerClusterGpSinkTableRequestCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t index); /** @brief Green Power Cluster Gp Sink Table Response * - * + * * * @param status Ver.: always * @param totalNumberofNonEmptySinkTableEntries Ver.: always @@ -6698,21 +6009,19 @@ bool emberAfGreenPowerClusterGpSinkTableRequestCallback(uint8_t options, * @param sinkTableEntriesCount Ver.: always * @param sinkTableEntries Ver.: always */ -bool emberAfGreenPowerClusterGpSinkTableResponseCallback(uint8_t status, - uint8_t totalNumberofNonEmptySinkTableEntries, - uint8_t startIndex, - uint8_t sinkTableEntriesCount, - uint8_t* sinkTableEntries); +bool emberAfGreenPowerClusterGpSinkTableResponseCallback(uint8_t status, uint8_t totalNumberofNonEmptySinkTableEntries, + uint8_t startIndex, uint8_t sinkTableEntriesCount, + uint8_t * sinkTableEntries); /** @brief Green Power Cluster Gp Translation Table Request * - * + * * * @param startIndex Ver.: since gp-1.0-09-5499-24 */ bool emberAfGreenPowerClusterGpTranslationTableRequestCallback(uint8_t startIndex); /** @brief Green Power Cluster Gp Translation Table Response * - * + * * * @param status Ver.: since gp-1.0-09-5499-24 * @param options Ver.: since gp-1.0-09-5499-24 @@ -6721,15 +6030,12 @@ bool emberAfGreenPowerClusterGpTranslationTableRequestCallback(uint8_t startInde * @param entriesCount Ver.: since gp-1.0-09-5499-24 * @param translationTableList Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpTranslationTableResponseCallback(uint8_t status, - uint8_t options, - uint8_t totalNumberOfEntries, - uint8_t startIndex, - uint8_t entriesCount, - uint8_t* translationTableList); +bool emberAfGreenPowerClusterGpTranslationTableResponseCallback(uint8_t status, uint8_t options, uint8_t totalNumberOfEntries, + uint8_t startIndex, uint8_t entriesCount, + uint8_t * translationTableList); /** @brief Green Power Cluster Gp Translation Table Update * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6737,14 +6043,11 @@ bool emberAfGreenPowerClusterGpTranslationTableResponseCallback(uint8_t status, * @param endpoint Ver.: since gp-1.0-09-5499-24 * @param translations Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpTranslationTableUpdateCallback(uint16_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint8_t* translations); +bool emberAfGreenPowerClusterGpTranslationTableUpdateCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, + uint8_t endpoint, uint8_t * translations); /** @brief Green Power Cluster Gp Tunneling Stop * - * + * * * @param options Ver.: since gp-1.0-09-5499-24 * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 @@ -6754,13 +6057,9 @@ bool emberAfGreenPowerClusterGpTranslationTableUpdateCallback(uint16_t options, * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 * @param gppDistance Ver.: since gp-1.0-09-5499-24 */ -bool emberAfGreenPowerClusterGpTunnelingStopCallback(uint8_t options, - uint32_t gpdSrcId, - uint8_t* gpdIeee, - uint8_t endpoint, - uint32_t gpdSecurityFrameCounter, - uint16_t gppShortAddress, - int8_t gppDistance); +bool emberAfGreenPowerClusterGpTunnelingStopCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint32_t gpdSecurityFrameCounter, uint16_t gppShortAddress, + int8_t gppDistance); /** @brief Green Power Cluster Server Attribute Changed * * Server Attribute Changed @@ -6768,8 +6067,7 @@ bool emberAfGreenPowerClusterGpTunnelingStopCallback(uint8_t options, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGreenPowerClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGreenPowerClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Green Power Cluster Server Default Response * * This function is called when the server receives the default response from @@ -6779,9 +6077,7 @@ void emberAfGreenPowerClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGreenPowerClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGreenPowerClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Green Power Cluster Server Init * * Server Init @@ -6795,11 +6091,10 @@ void emberAfGreenPowerClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGreenPowerClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGreenPowerClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Green Power Cluster Server Message Sent * @@ -6813,11 +6108,8 @@ void emberAfGreenPowerClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGreenPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGreenPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Green Power Cluster Server Pre Attribute Changed * @@ -6829,11 +6121,9 @@ void emberAfGreenPowerClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGreenPowerClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGreenPowerClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Green Power Cluster Server Tick * * Server Tick @@ -6854,8 +6144,7 @@ void emberAfGreenPowerClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfKeepaliveClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfKeepaliveClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Keep-Alive Cluster Client Default Response * * This function is called when the client receives the default response from @@ -6865,9 +6154,7 @@ void emberAfKeepaliveClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfKeepaliveClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfKeepaliveClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Keep-Alive Cluster Client Init * * Client Init @@ -6881,11 +6168,10 @@ void emberAfKeepaliveClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfKeepaliveClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfKeepaliveClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Keep-Alive Cluster Client Message Sent * @@ -6899,11 +6185,8 @@ void emberAfKeepaliveClusterClientManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfKeepaliveClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfKeepaliveClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Keep-Alive Cluster Client Pre Attribute Changed * @@ -6915,11 +6198,9 @@ void emberAfKeepaliveClusterClientMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfKeepaliveClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfKeepaliveClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Keep-Alive Cluster Client Tick * * Client Tick @@ -6934,8 +6215,7 @@ void emberAfKeepaliveClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfKeepaliveClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfKeepaliveClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Keep-Alive Cluster Server Default Response * * This function is called when the server receives the default response from @@ -6945,9 +6225,7 @@ void emberAfKeepaliveClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfKeepaliveClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfKeepaliveClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Keep-Alive Cluster Server Init * * Server Init @@ -6961,11 +6239,10 @@ void emberAfKeepaliveClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfKeepaliveClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfKeepaliveClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Keep-Alive Cluster Server Message Sent * @@ -6979,11 +6256,8 @@ void emberAfKeepaliveClusterServerManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfKeepaliveClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfKeepaliveClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Keep-Alive Cluster Server Pre Attribute Changed * @@ -6995,11 +6269,9 @@ void emberAfKeepaliveClusterServerMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfKeepaliveClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfKeepaliveClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Keep-Alive Cluster Server Tick * * Server Tick @@ -7020,8 +6292,7 @@ void emberAfKeepaliveClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfShadeConfigClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfShadeConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Shade Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -7031,9 +6302,7 @@ void emberAfShadeConfigClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfShadeConfigClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfShadeConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Shade Configuration Cluster Client Init * * Client Init @@ -7047,11 +6316,10 @@ void emberAfShadeConfigClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfShadeConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfShadeConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Shade Configuration Cluster Client Message Sent * @@ -7065,11 +6333,8 @@ void emberAfShadeConfigClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfShadeConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfShadeConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Shade Configuration Cluster Client Pre Attribute Changed * @@ -7081,11 +6346,9 @@ void emberAfShadeConfigClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfShadeConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfShadeConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Shade Configuration Cluster Client Tick * * Client Tick @@ -7100,8 +6363,7 @@ void emberAfShadeConfigClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfShadeConfigClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfShadeConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Shade Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -7111,9 +6373,7 @@ void emberAfShadeConfigClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfShadeConfigClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfShadeConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Shade Configuration Cluster Server Init * * Server Init @@ -7127,11 +6387,10 @@ void emberAfShadeConfigClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfShadeConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfShadeConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Shade Configuration Cluster Server Message Sent * @@ -7145,11 +6404,8 @@ void emberAfShadeConfigClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfShadeConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfShadeConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Shade Configuration Cluster Server Pre Attribute Changed * @@ -7161,11 +6417,9 @@ void emberAfShadeConfigClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfShadeConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfShadeConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Shade Configuration Cluster Server Tick * * Server Tick @@ -7181,100 +6435,98 @@ void emberAfShadeConfigClusterServerTickCallback(uint8_t endpoint); /** @brief Door Lock Cluster Clear All Pins * - * + * * */ bool emberAfDoorLockClusterClearAllPinsCallback(void); /** @brief Door Lock Cluster Clear All Pins Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear All Rfids * - * + * * */ bool emberAfDoorLockClusterClearAllRfidsCallback(void); /** @brief Door Lock Cluster Clear All Rfids Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear Holiday Schedule * - * + * * * @param scheduleId Ver.: always */ bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId); /** @brief Door Lock Cluster Clear Holiday Schedule Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear Pin * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterClearPinCallback(uint16_t userId); /** @brief Door Lock Cluster Clear Pin Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear Rfid * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId); /** @brief Door Lock Cluster Clear Rfid Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear Weekday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always */ -bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, - uint16_t userId); +bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId); /** @brief Door Lock Cluster Clear Weekday Schedule Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Clear Yearday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always */ -bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, - uint16_t userId); +bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId); /** @brief Door Lock Cluster Clear Yearday Schedule Response * - * + * * * @param status Ver.: always */ @@ -7286,8 +6538,7 @@ bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDoorLockClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDoorLockClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Door Lock Cluster Client Default Response * * This function is called when the client receives the default response from @@ -7297,9 +6548,7 @@ void emberAfDoorLockClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDoorLockClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDoorLockClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Door Lock Cluster Client Init * * Client Init @@ -7313,11 +6562,10 @@ void emberAfDoorLockClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Door Lock Cluster Client Message Sent * @@ -7331,11 +6579,8 @@ void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Door Lock Cluster Client Pre Attribute Changed * @@ -7347,11 +6592,9 @@ void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Door Lock Cluster Client Tick * * Client Tick @@ -7361,14 +6604,14 @@ EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(uint8_t en void emberAfDoorLockClusterClientTickCallback(uint8_t endpoint); /** @brief Door Lock Cluster Get Holiday Schedule * - * + * * * @param scheduleId Ver.: always */ bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId); /** @brief Door Lock Cluster Get Holiday Schedule Response * - * + * * * @param scheduleId Ver.: always * @param status Ver.: always @@ -7376,21 +6619,18 @@ bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId); * @param localEndTime Ver.: since ha-1.2-05-3520-29 * @param operatingModeDuringHoliday Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, - uint8_t status, - uint32_t localStartTime, - uint32_t localEndTime, - uint8_t operatingModeDuringHoliday); +bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime, + uint32_t localEndTime, uint8_t operatingModeDuringHoliday); /** @brief Door Lock Cluster Get Log Record * - * + * * * @param logIndex Ver.: always */ bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex); /** @brief Door Lock Cluster Get Log Record Response * - * + * * * @param logEntryId Ver.: always * @param timestamp Ver.: always @@ -7400,97 +6640,83 @@ bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex); * @param userId Ver.: always * @param pin Ver.: always */ -bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, - uint32_t timestamp, - uint8_t eventType, - uint8_t source, - uint8_t eventIdOrAlarmCode, - uint16_t userId, - uint8_t* pin); +bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source, + uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin); /** @brief Door Lock Cluster Get Pin * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterGetPinCallback(uint16_t userId); /** @brief Door Lock Cluster Get Pin Response * - * + * * * @param userId Ver.: always * @param userStatus Ver.: always * @param userType Ver.: always * @param pin Ver.: always */ -bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, - uint8_t userStatus, - uint8_t userType, - uint8_t* pin); +bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin); /** @brief Door Lock Cluster Get Rfid * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId); /** @brief Door Lock Cluster Get Rfid Response * - * + * * * @param userId Ver.: always * @param userStatus Ver.: always * @param userType Ver.: always * @param rfid Ver.: always */ -bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, - uint8_t userStatus, - uint8_t userType, - uint8_t* rfid); +bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid); /** @brief Door Lock Cluster Get User Status * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterGetUserStatusCallback(uint16_t userId); /** @brief Door Lock Cluster Get User Status Response * - * + * * * @param userId Ver.: always * @param status Ver.: always */ -bool emberAfDoorLockClusterGetUserStatusResponseCallback(uint16_t userId, - uint8_t status); +bool emberAfDoorLockClusterGetUserStatusResponseCallback(uint16_t userId, uint8_t status); /** @brief Door Lock Cluster Get User Type * - * + * * * @param userId Ver.: always */ bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId); /** @brief Door Lock Cluster Get User Type Response * - * + * * * @param userId Ver.: always * @param userType Ver.: always */ -bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, - uint8_t userType); +bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType); /** @brief Door Lock Cluster Get Weekday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always */ -bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, - uint16_t userId); +bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId); /** @brief Door Lock Cluster Get Weekday Schedule Response * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always @@ -7501,26 +6727,20 @@ bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, * @param endHour Ver.: since ha-1.2-05-3520-29 * @param endMinute Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, - uint16_t userId, - uint8_t status, - uint8_t daysMask, - uint8_t startHour, - uint8_t startMinute, - uint8_t endHour, - uint8_t endMinute); +bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, uint8_t daysMask, + uint8_t startHour, uint8_t startMinute, uint8_t endHour, + uint8_t endMinute); /** @brief Door Lock Cluster Get Yearday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always */ -bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, - uint16_t userId); +bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId); /** @brief Door Lock Cluster Get Yearday Schedule Response * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always @@ -7528,28 +6748,25 @@ bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, * @param localStartTime Ver.: since ha-1.2-05-3520-29 * @param localEndTime Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, - uint16_t userId, - uint8_t status, - uint32_t localStartTime, - uint32_t localEndTime); +bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, + uint32_t localStartTime, uint32_t localEndTime); /** @brief Door Lock Cluster Lock Door * - * + * * * @param PIN Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterLockDoorCallback(uint8_t* PIN); +bool emberAfDoorLockClusterLockDoorCallback(uint8_t * PIN); /** @brief Door Lock Cluster Lock Door Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status); /** @brief Door Lock Cluster Operation Event Notification * - * + * * * @param source Ver.: always * @param eventCode Ver.: always @@ -7558,15 +6775,11 @@ bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status); * @param timeStamp Ver.: always * @param data Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterOperationEventNotificationCallback(uint8_t source, - uint8_t eventCode, - uint16_t userId, - uint8_t* pin, - uint32_t timeStamp, - uint8_t* data); +bool emberAfDoorLockClusterOperationEventNotificationCallback(uint8_t source, uint8_t eventCode, uint16_t userId, uint8_t * pin, + uint32_t timeStamp, uint8_t * data); /** @brief Door Lock Cluster Programming Event Notification * - * + * * * @param source Ver.: always * @param eventCode Ver.: always @@ -7577,14 +6790,9 @@ bool emberAfDoorLockClusterOperationEventNotificationCallback(uint8_t source, * @param timeStamp Ver.: always * @param data Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterProgrammingEventNotificationCallback(uint8_t source, - uint8_t eventCode, - uint16_t userId, - uint8_t* pin, - uint8_t userType, - uint8_t userStatus, - uint32_t timeStamp, - uint8_t* data); +bool emberAfDoorLockClusterProgrammingEventNotificationCallback(uint8_t source, uint8_t eventCode, uint16_t userId, uint8_t * pin, + uint8_t userType, uint8_t userStatus, uint32_t timeStamp, + uint8_t * data); /** @brief Door Lock Cluster Server Attribute Changed * * Server Attribute Changed @@ -7592,8 +6800,7 @@ bool emberAfDoorLockClusterProgrammingEventNotificationCallback(uint8_t source, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Door Lock Cluster Server Default Response * * This function is called when the server receives the default response from @@ -7603,9 +6810,7 @@ void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDoorLockClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDoorLockClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Door Lock Cluster Server Init * * Server Init @@ -7619,11 +6824,10 @@ void emberAfDoorLockClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Door Lock Cluster Server Message Sent * @@ -7637,11 +6841,8 @@ void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Door Lock Cluster Server Pre Attribute Changed * @@ -7653,11 +6854,9 @@ void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Door Lock Cluster Server Tick * * Server Tick @@ -7667,99 +6866,89 @@ EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(uint8_t en void emberAfDoorLockClusterServerTickCallback(uint8_t endpoint); /** @brief Door Lock Cluster Set Holiday Schedule * - * + * * * @param scheduleId Ver.: always * @param localStartTime Ver.: always * @param localEndTime Ver.: always * @param operatingModeDuringHoliday Ver.: always */ -bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, - uint32_t localStartTime, - uint32_t localEndTime, - uint8_t operatingModeDuringHoliday); +bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime, + uint8_t operatingModeDuringHoliday); /** @brief Door Lock Cluster Set Holiday Schedule Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set Pin * - * + * * * @param userId Ver.: always * @param userStatus Ver.: always * @param userType Ver.: always * @param pin Ver.: always */ -bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, - uint8_t userStatus, - uint8_t userType, - uint8_t* pin); +bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin); /** @brief Door Lock Cluster Set Pin Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set Rfid * - * + * * * @param userId Ver.: always * @param userStatus Ver.: always * @param userType Ver.: always * @param id Ver.: always */ -bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, - uint8_t userStatus, - uint8_t userType, - uint8_t* id); +bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * id); /** @brief Door Lock Cluster Set Rfid Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set User Status * - * + * * * @param userId Ver.: always * @param userStatus Ver.: always */ -bool emberAfDoorLockClusterSetUserStatusCallback(uint16_t userId, - uint8_t userStatus); +bool emberAfDoorLockClusterSetUserStatusCallback(uint16_t userId, uint8_t userStatus); /** @brief Door Lock Cluster Set User Status Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetUserStatusResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set User Type * - * + * * * @param userId Ver.: always * @param userType Ver.: always */ -bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, - uint8_t userType); +bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, uint8_t userType); /** @brief Door Lock Cluster Set User Type Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set Weekday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always @@ -7769,80 +6958,72 @@ bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status); * @param endHour Ver.: always * @param endMinute Ver.: always */ -bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, - uint16_t userId, - uint8_t daysMask, - uint8_t startHour, - uint8_t startMinute, - uint8_t endHour, - uint8_t endMinute); +bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour, + uint8_t startMinute, uint8_t endHour, uint8_t endMinute); /** @brief Door Lock Cluster Set Weekday Schedule Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Set Yearday Schedule * - * + * * * @param scheduleId Ver.: always * @param userId Ver.: always * @param localStartTime Ver.: always * @param localEndTime Ver.: always */ -bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, - uint16_t userId, - uint32_t localStartTime, - uint32_t localEndTime); +bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, + uint32_t localEndTime); /** @brief Door Lock Cluster Set Yearday Schedule Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Toggle * - * + * * * @param pin Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterToggleCallback(uint8_t* pin); +bool emberAfDoorLockClusterToggleCallback(uint8_t * pin); /** @brief Door Lock Cluster Toggle Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterToggleResponseCallback(uint8_t status); /** @brief Door Lock Cluster Unlock Door * - * + * * * @param PIN Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t* PIN); +bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t * PIN); /** @brief Door Lock Cluster Unlock Door Response * - * + * * * @param status Ver.: always */ bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status); /** @brief Door Lock Cluster Unlock With Timeout * - * + * * * @param timeoutInSeconds Ver.: always * @param pin Ver.: since ha-1.2-05-3520-29 */ -bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, - uint8_t* pin); +bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, uint8_t * pin); /** @brief Door Lock Cluster Unlock With Timeout Response * - * + * * * @param status Ver.: always */ @@ -7860,8 +7041,7 @@ bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfWindowCoveringClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfWindowCoveringClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Window Covering Cluster Client Default Response * * This function is called when the client receives the default response from @@ -7871,9 +7051,7 @@ void emberAfWindowCoveringClusterClientAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfWindowCoveringClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfWindowCoveringClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Window Covering Cluster Client Init * * Client Init @@ -7887,7 +7065,7 @@ void emberAfWindowCoveringClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfWindowCoveringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -7905,11 +7083,8 @@ void emberAfWindowCoveringClusterClientManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfWindowCoveringClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfWindowCoveringClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Window Covering Cluster Client Pre Attribute Changed * @@ -7921,11 +7096,9 @@ void emberAfWindowCoveringClusterClientMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfWindowCoveringClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfWindowCoveringClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Window Covering Cluster Client Tick * * Client Tick @@ -7940,8 +7113,7 @@ void emberAfWindowCoveringClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfWindowCoveringClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfWindowCoveringClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Window Covering Cluster Server Default Response * * This function is called when the server receives the default response from @@ -7951,9 +7123,7 @@ void emberAfWindowCoveringClusterServerAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfWindowCoveringClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfWindowCoveringClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Window Covering Cluster Server Init * * Server Init @@ -7967,7 +7137,7 @@ void emberAfWindowCoveringClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfWindowCoveringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -7985,11 +7155,8 @@ void emberAfWindowCoveringClusterServerManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfWindowCoveringClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfWindowCoveringClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Window Covering Cluster Server Pre Attribute Changed * @@ -8001,11 +7168,9 @@ void emberAfWindowCoveringClusterServerMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Window Covering Cluster Server Tick * * Server Tick @@ -8015,47 +7180,47 @@ EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(uint void emberAfWindowCoveringClusterServerTickCallback(uint8_t endpoint); /** @brief Window Covering Cluster Window Covering Down Close * - * + * * */ bool emberAfWindowCoveringClusterWindowCoveringDownCloseCallback(void); /** @brief Window Covering Cluster Window Covering Go To Lift Percentage * - * + * * * @param percentageLiftValue Ver.: always */ bool emberAfWindowCoveringClusterWindowCoveringGoToLiftPercentageCallback(uint8_t percentageLiftValue); /** @brief Window Covering Cluster Window Covering Go To Lift Value * - * + * * * @param liftValue Ver.: always */ bool emberAfWindowCoveringClusterWindowCoveringGoToLiftValueCallback(uint16_t liftValue); /** @brief Window Covering Cluster Window Covering Go To Tilt Percentage * - * + * * * @param percentageTiltValue Ver.: always */ bool emberAfWindowCoveringClusterWindowCoveringGoToTiltPercentageCallback(uint8_t percentageTiltValue); /** @brief Window Covering Cluster Window Covering Go To Tilt Value * - * + * * * @param tiltValue Ver.: always */ bool emberAfWindowCoveringClusterWindowCoveringGoToTiltValueCallback(uint16_t tiltValue); /** @brief Window Covering Cluster Window Covering Stop * - * + * * */ bool emberAfWindowCoveringClusterWindowCoveringStopCallback(void); /** @brief Window Covering Cluster Window Covering Up Open * - * + * * */ bool emberAfWindowCoveringClusterWindowCoveringUpOpenCallback(void); @@ -8067,14 +7232,14 @@ bool emberAfWindowCoveringClusterWindowCoveringUpOpenCallback(void); /** @brief Barrier Control Cluster Barrier Control Go To Percent * - * + * * * @param percentOpen Ver.: always */ bool emberAfBarrierControlClusterBarrierControlGoToPercentCallback(uint8_t percentOpen); /** @brief Barrier Control Cluster Barrier Control Stop * - * + * * */ bool emberAfBarrierControlClusterBarrierControlStopCallback(void); @@ -8085,8 +7250,7 @@ bool emberAfBarrierControlClusterBarrierControlStopCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBarrierControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBarrierControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Barrier Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8096,9 +7260,7 @@ void emberAfBarrierControlClusterClientAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBarrierControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBarrierControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Barrier Control Cluster Client Init * * Client Init @@ -8112,7 +7274,7 @@ void emberAfBarrierControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBarrierControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8130,11 +7292,8 @@ void emberAfBarrierControlClusterClientManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Barrier Control Cluster Client Pre Attribute Changed * @@ -8146,11 +7305,9 @@ void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBarrierControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBarrierControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Barrier Control Cluster Client Tick * * Client Tick @@ -8165,8 +7322,7 @@ void emberAfBarrierControlClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBarrierControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBarrierControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Barrier Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -8176,9 +7332,7 @@ void emberAfBarrierControlClusterServerAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBarrierControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBarrierControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Barrier Control Cluster Server Init * * Server Init @@ -8192,7 +7346,7 @@ void emberAfBarrierControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8210,11 +7364,8 @@ void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Barrier Control Cluster Server Pre Attribute Changed * @@ -8226,11 +7377,9 @@ void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Barrier Control Cluster Server Tick * * Server Tick @@ -8251,8 +7400,7 @@ void emberAfBarrierControlClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPumpConfigControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPumpConfigControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Pump Configuration and Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8262,9 +7410,7 @@ void emberAfPumpConfigControlClusterClientAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPumpConfigControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPumpConfigControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Pump Configuration and Control Cluster Client Init * * Client Init @@ -8278,7 +7424,7 @@ void emberAfPumpConfigControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfPumpConfigControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8296,11 +7442,8 @@ void emberAfPumpConfigControlClusterClientManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPumpConfigControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPumpConfigControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Pump Configuration and Control Cluster Client Pre Attribute Changed * @@ -8312,11 +7455,9 @@ void emberAfPumpConfigControlClusterClientMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPumpConfigControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPumpConfigControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Pump Configuration and Control Cluster Client Tick * * Client Tick @@ -8331,8 +7472,7 @@ void emberAfPumpConfigControlClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPumpConfigControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPumpConfigControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Pump Configuration and Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -8342,9 +7482,7 @@ void emberAfPumpConfigControlClusterServerAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPumpConfigControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPumpConfigControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Pump Configuration and Control Cluster Server Init * * Server Init @@ -8358,7 +7496,7 @@ void emberAfPumpConfigControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfPumpConfigControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8376,11 +7514,8 @@ void emberAfPumpConfigControlClusterServerManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPumpConfigControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPumpConfigControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Pump Configuration and Control Cluster Server Pre Attribute Changed * @@ -8392,11 +7527,9 @@ void emberAfPumpConfigControlClusterServerMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPumpConfigControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPumpConfigControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Pump Configuration and Control Cluster Server Tick * * Server Tick @@ -8412,7 +7545,7 @@ void emberAfPumpConfigControlClusterServerTickCallback(uint8_t endpoint); /** @brief Thermostat Cluster Clear Weekly Schedule * - * + * * */ bool emberAfThermostatClusterClearWeeklyScheduleCallback(void); @@ -8423,8 +7556,7 @@ bool emberAfThermostatClusterClearWeeklyScheduleCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfThermostatClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfThermostatClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Thermostat Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8434,9 +7566,7 @@ void emberAfThermostatClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfThermostatClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfThermostatClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Thermostat Cluster Client Init * * Client Init @@ -8450,11 +7580,10 @@ void emberAfThermostatClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfThermostatClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfThermostatClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Thermostat Cluster Client Message Sent * @@ -8468,11 +7597,8 @@ void emberAfThermostatClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfThermostatClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfThermostatClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Thermostat Cluster Client Pre Attribute Changed * @@ -8484,11 +7610,9 @@ void emberAfThermostatClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfThermostatClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfThermostatClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Thermostat Cluster Client Tick * * Client Tick @@ -8498,35 +7622,32 @@ EmberAfStatus emberAfThermostatClusterClientPreAttributeChangedCallback(uint8_t void emberAfThermostatClusterClientTickCallback(uint8_t endpoint); /** @brief Thermostat Cluster Current Weekly Schedule * - * + * * * @param numberOfTransitionsForSequence Ver.: always * @param dayOfWeekForSequence Ver.: always * @param modeForSequence Ver.: always * @param payload Ver.: always */ -bool emberAfThermostatClusterCurrentWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, - uint8_t dayOfWeekForSequence, - uint8_t modeForSequence, - uint8_t* payload); +bool emberAfThermostatClusterCurrentWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, uint8_t * payload); /** @brief Thermostat Cluster Get Relay Status Log * - * + * * */ bool emberAfThermostatClusterGetRelayStatusLogCallback(void); /** @brief Thermostat Cluster Get Weekly Schedule * - * + * * * @param daysToReturn Ver.: always * @param modeToReturn Ver.: always */ -bool emberAfThermostatClusterGetWeeklyScheduleCallback(uint8_t daysToReturn, - uint8_t modeToReturn); +bool emberAfThermostatClusterGetWeeklyScheduleCallback(uint8_t daysToReturn, uint8_t modeToReturn); /** @brief Thermostat Cluster Relay Status Log * - * + * * * @param timeOfDay Ver.: always * @param relayStatus Ver.: always @@ -8535,12 +7656,8 @@ bool emberAfThermostatClusterGetWeeklyScheduleCallback(uint8_t daysToReturn, * @param setpoint Ver.: always * @param unreadEntries Ver.: always */ -bool emberAfThermostatClusterRelayStatusLogCallback(uint16_t timeOfDay, - uint16_t relayStatus, - int16_t localTemperature, - uint8_t humidityInPercentage, - int16_t setpoint, - uint16_t unreadEntries); +bool emberAfThermostatClusterRelayStatusLogCallback(uint16_t timeOfDay, uint16_t relayStatus, int16_t localTemperature, + uint8_t humidityInPercentage, int16_t setpoint, uint16_t unreadEntries); /** @brief Thermostat Cluster Server Attribute Changed * * Server Attribute Changed @@ -8548,8 +7665,7 @@ bool emberAfThermostatClusterRelayStatusLogCallback(uint16_t timeOfDay, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfThermostatClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfThermostatClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Thermostat Cluster Server Default Response * * This function is called when the server receives the default response from @@ -8559,9 +7675,7 @@ void emberAfThermostatClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfThermostatClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfThermostatClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Thermostat Cluster Server Init * * Server Init @@ -8575,11 +7689,10 @@ void emberAfThermostatClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Thermostat Cluster Server Message Sent * @@ -8593,11 +7706,8 @@ void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfThermostatClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfThermostatClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Thermostat Cluster Server Pre Attribute Changed * @@ -8609,11 +7719,9 @@ void emberAfThermostatClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Thermostat Cluster Server Tick * * Server Tick @@ -8623,26 +7731,23 @@ EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(uint8_t void emberAfThermostatClusterServerTickCallback(uint8_t endpoint); /** @brief Thermostat Cluster Set Weekly Schedule * - * + * * * @param numberOfTransitionsForSequence Ver.: always * @param dayOfWeekForSequence Ver.: always * @param modeForSequence Ver.: always * @param payload Ver.: always */ -bool emberAfThermostatClusterSetWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, - uint8_t dayOfWeekForSequence, - uint8_t modeForSequence, - uint8_t* payload); +bool emberAfThermostatClusterSetWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, uint8_t * payload); /** @brief Thermostat Cluster Setpoint Raise Lower * - * + * * * @param mode Ver.: always * @param amount Ver.: always */ -bool emberAfThermostatClusterSetpointRaiseLowerCallback(uint8_t mode, - int8_t amount); +bool emberAfThermostatClusterSetpointRaiseLowerCallback(uint8_t mode, int8_t amount); /** @} END Thermostat Cluster Callbacks */ @@ -8656,8 +7761,7 @@ bool emberAfThermostatClusterSetpointRaiseLowerCallback(uint8_t mode, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFanControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFanControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Fan Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8667,9 +7771,7 @@ void emberAfFanControlClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFanControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfFanControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fan Control Cluster Client Init * * Client Init @@ -8683,11 +7785,10 @@ void emberAfFanControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFanControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfFanControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fan Control Cluster Client Message Sent * @@ -8701,11 +7802,8 @@ void emberAfFanControlClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfFanControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfFanControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Fan Control Cluster Client Pre Attribute Changed * @@ -8717,11 +7815,9 @@ void emberAfFanControlClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFanControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFanControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Fan Control Cluster Client Tick * * Client Tick @@ -8736,8 +7832,7 @@ void emberAfFanControlClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFanControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFanControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Fan Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -8747,9 +7842,7 @@ void emberAfFanControlClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFanControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfFanControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fan Control Cluster Server Init * * Server Init @@ -8763,11 +7856,10 @@ void emberAfFanControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFanControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfFanControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fan Control Cluster Server Message Sent * @@ -8781,11 +7873,8 @@ void emberAfFanControlClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfFanControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfFanControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Fan Control Cluster Server Pre Attribute Changed * @@ -8797,11 +7886,9 @@ void emberAfFanControlClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFanControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFanControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Fan Control Cluster Server Tick * * Server Tick @@ -8822,8 +7909,7 @@ void emberAfFanControlClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDehumidControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDehumidControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Dehumidification Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8833,9 +7919,7 @@ void emberAfDehumidControlClusterClientAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDehumidControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDehumidControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Dehumidification Control Cluster Client Init * * Client Init @@ -8849,7 +7933,7 @@ void emberAfDehumidControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDehumidControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8867,11 +7951,8 @@ void emberAfDehumidControlClusterClientManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDehumidControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDehumidControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Dehumidification Control Cluster Client Pre Attribute Changed * @@ -8883,11 +7964,9 @@ void emberAfDehumidControlClusterClientMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDehumidControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDehumidControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Dehumidification Control Cluster Client Tick * * Client Tick @@ -8902,8 +7981,7 @@ void emberAfDehumidControlClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDehumidControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDehumidControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Dehumidification Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -8913,9 +7991,7 @@ void emberAfDehumidControlClusterServerAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDehumidControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDehumidControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Dehumidification Control Cluster Server Init * * Server Init @@ -8929,7 +8005,7 @@ void emberAfDehumidControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDehumidControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -8947,11 +8023,8 @@ void emberAfDehumidControlClusterServerManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDehumidControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDehumidControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Dehumidification Control Cluster Server Pre Attribute Changed * @@ -8963,11 +8036,9 @@ void emberAfDehumidControlClusterServerMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDehumidControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDehumidControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Dehumidification Control Cluster Server Tick * * Server Tick @@ -8988,8 +8059,7 @@ void emberAfDehumidControlClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfThermostatUiConfigClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfThermostatUiConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Thermostat User Interface Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -8999,9 +8069,7 @@ void emberAfThermostatUiConfigClusterClientAttributeChangedCallback(uint8_t endp * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfThermostatUiConfigClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfThermostatUiConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Thermostat User Interface Configuration Cluster Client Init * * Client Init @@ -9015,7 +8083,7 @@ void emberAfThermostatUiConfigClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfThermostatUiConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9033,11 +8101,8 @@ void emberAfThermostatUiConfigClusterClientManufacturerSpecificAttributeChangedC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfThermostatUiConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfThermostatUiConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Thermostat User Interface Configuration Cluster Client Pre Attribute Changed * @@ -9049,11 +8114,9 @@ void emberAfThermostatUiConfigClusterClientMessageSentCallback(EmberOutgoingMess * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfThermostatUiConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfThermostatUiConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Thermostat User Interface Configuration Cluster Client Tick * * Client Tick @@ -9068,8 +8131,7 @@ void emberAfThermostatUiConfigClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfThermostatUiConfigClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfThermostatUiConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Thermostat User Interface Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -9079,9 +8141,7 @@ void emberAfThermostatUiConfigClusterServerAttributeChangedCallback(uint8_t endp * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfThermostatUiConfigClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfThermostatUiConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Thermostat User Interface Configuration Cluster Server Init * * Server Init @@ -9095,7 +8155,7 @@ void emberAfThermostatUiConfigClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfThermostatUiConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9113,11 +8173,8 @@ void emberAfThermostatUiConfigClusterServerManufacturerSpecificAttributeChangedC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfThermostatUiConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfThermostatUiConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Thermostat User Interface Configuration Cluster Server Pre Attribute Changed * @@ -9129,11 +8186,9 @@ void emberAfThermostatUiConfigClusterServerMessageSentCallback(EmberOutgoingMess * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfThermostatUiConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfThermostatUiConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Thermostat User Interface Configuration Cluster Server Tick * * Server Tick @@ -9154,8 +8209,7 @@ void emberAfThermostatUiConfigClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfColorControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfColorControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Color Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -9165,9 +8219,7 @@ void emberAfColorControlClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfColorControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfColorControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Color Control Cluster Client Init * * Client Init @@ -9181,11 +8233,10 @@ void emberAfColorControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Color Control Cluster Client Message Sent * @@ -9199,11 +8250,8 @@ void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Color Control Cluster Client Pre Attribute Changed * @@ -9215,11 +8263,9 @@ void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Color Control Cluster Client Tick * * Client Tick @@ -9229,7 +8275,7 @@ EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(uint8_ void emberAfColorControlClusterClientTickCallback(uint8_t endpoint); /** @brief Color Control Cluster Color Loop Set * - * + * * * @param updateFlags Ver.: always * @param action Ver.: always @@ -9237,69 +8283,57 @@ void emberAfColorControlClusterClientTickCallback(uint8_t endpoint); * @param time Ver.: always * @param startHue Ver.: always */ -bool emberAfColorControlClusterColorLoopSetCallback(uint8_t updateFlags, - uint8_t action, - uint8_t direction, - uint16_t time, - uint16_t startHue); +bool emberAfColorControlClusterColorLoopSetCallback(uint8_t updateFlags, uint8_t action, uint8_t direction, uint16_t time, + uint16_t startHue); /** @brief Color Control Cluster Enhanced Move Hue * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always */ -bool emberAfColorControlClusterEnhancedMoveHueCallback(uint8_t moveMode, - uint16_t rate); +bool emberAfColorControlClusterEnhancedMoveHueCallback(uint8_t moveMode, uint16_t rate); /** @brief Color Control Cluster Enhanced Move To Hue And Saturation * - * + * * * @param enhancedHue Ver.: always * @param saturation Ver.: always * @param transitionTime Ver.: always */ -bool emberAfColorControlClusterEnhancedMoveToHueAndSaturationCallback(uint16_t enhancedHue, - uint8_t saturation, - uint16_t transitionTime); +bool emberAfColorControlClusterEnhancedMoveToHueAndSaturationCallback(uint16_t enhancedHue, uint8_t saturation, + uint16_t transitionTime); /** @brief Color Control Cluster Enhanced Move To Hue * - * + * * * @param enhancedHue Ver.: always * @param direction Ver.: always * @param transitionTime Ver.: always */ -bool emberAfColorControlClusterEnhancedMoveToHueCallback(uint16_t enhancedHue, - uint8_t direction, - uint16_t transitionTime); +bool emberAfColorControlClusterEnhancedMoveToHueCallback(uint16_t enhancedHue, uint8_t direction, uint16_t transitionTime); /** @brief Color Control Cluster Enhanced Step Hue * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always * @param transitionTime Ver.: always */ -bool emberAfColorControlClusterEnhancedStepHueCallback(uint8_t stepMode, - uint16_t stepSize, - uint16_t transitionTime); +bool emberAfColorControlClusterEnhancedStepHueCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime); /** @brief Color Control Cluster Move Color * - * + * * * @param rateX Ver.: always * @param rateY Ver.: always * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, - int16_t rateY, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Move Color Temperature * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always @@ -9308,41 +8342,32 @@ bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, - uint16_t rate, - uint16_t colorTemperatureMinimum, - uint16_t colorTemperatureMaximum, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, uint16_t rate, uint16_t colorTemperatureMinimum, + uint16_t colorTemperatureMaximum, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Move Hue * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, - uint8_t rate, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Move Saturation * - * + * * * @param moveMode Ver.: always * @param rate Ver.: always * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, - uint8_t rate, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Move To Color * - * + * * * @param colorX Ver.: always * @param colorY Ver.: always @@ -9350,27 +8375,22 @@ bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, - uint16_t colorY, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Move To Color Temperature * - * + * * * @param colorTemperature Ver.: always * @param transitionTime Ver.: always * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, uint16_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Move To Hue And Saturation * - * + * * * @param hue Ver.: always * @param saturation Ver.: always @@ -9378,14 +8398,11 @@ bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemp * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, - uint8_t saturation, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, uint8_t saturation, uint16_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Move To Hue * - * + * * * @param hue Ver.: always * @param direction Ver.: always @@ -9393,24 +8410,19 @@ bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, - uint8_t direction, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Move To Saturation * - * + * * * @param saturation Ver.: always * @param transitionTime Ver.: always * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Server Attribute Changed * * Server Attribute Changed @@ -9418,8 +8430,7 @@ bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfColorControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfColorControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Color Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -9429,9 +8440,7 @@ void emberAfColorControlClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfColorControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfColorControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Color Control Cluster Server Init * * Server Init @@ -9445,11 +8454,10 @@ void emberAfColorControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Color Control Cluster Server Message Sent * @@ -9463,11 +8471,8 @@ void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallbac * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Color Control Cluster Server Pre Attribute Changed * @@ -9479,11 +8484,9 @@ void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageTyp * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Color Control Cluster Server Tick * * Server Tick @@ -9493,7 +8496,7 @@ EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(uint8_ void emberAfColorControlClusterServerTickCallback(uint8_t endpoint); /** @brief Color Control Cluster Step Color * - * + * * * @param stepX Ver.: always * @param stepY Ver.: always @@ -9501,14 +8504,11 @@ void emberAfColorControlClusterServerTickCallback(uint8_t endpoint); * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterStepColorCallback(int16_t stepX, - int16_t stepY, - uint16_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterStepColorCallback(int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Step Color Temperature * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always @@ -9518,16 +8518,12 @@ bool emberAfColorControlClusterStepColorCallback(int16_t stepX, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, - uint16_t stepSize, - uint16_t transitionTime, - uint16_t colorTemperatureMinimum, - uint16_t colorTemperatureMaximum, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime, + uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum, + uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Step Hue * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always @@ -9535,14 +8531,11 @@ bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, - uint8_t stepSize, - uint8_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); /** @brief Color Control Cluster Step Saturation * - * + * * * @param stepMode Ver.: always * @param stepSize Ver.: always @@ -9550,20 +8543,16 @@ bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, - uint8_t stepSize, - uint8_t transitionTime, - uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); /** @brief Color Control Cluster Stop Move Step * - * + * * * @param optionsMask Ver.: since zcl6-errata-14-0129-15 * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 */ -bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, - uint8_t optionsOverride); +bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, uint8_t optionsOverride); /** @} END Color Control Cluster Callbacks */ @@ -9577,8 +8566,7 @@ bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBallastConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBallastConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ballast Configuration Cluster Client Default Response * * This function is called when the client receives the default response from @@ -9588,9 +8576,7 @@ void emberAfBallastConfigurationClusterClientAttributeChangedCallback(uint8_t en * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBallastConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBallastConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ballast Configuration Cluster Client Init * * Client Init @@ -9604,7 +8590,7 @@ void emberAfBallastConfigurationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBallastConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9622,11 +8608,8 @@ void emberAfBallastConfigurationClusterClientManufacturerSpecificAttributeChange * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBallastConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBallastConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ballast Configuration Cluster Client Pre Attribute Changed * @@ -9638,11 +8621,9 @@ void emberAfBallastConfigurationClusterClientMessageSentCallback(EmberOutgoingMe * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBallastConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBallastConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Ballast Configuration Cluster Client Tick * * Client Tick @@ -9657,8 +8638,7 @@ void emberAfBallastConfigurationClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBallastConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBallastConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ballast Configuration Cluster Server Default Response * * This function is called when the server receives the default response from @@ -9668,9 +8648,7 @@ void emberAfBallastConfigurationClusterServerAttributeChangedCallback(uint8_t en * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBallastConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBallastConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ballast Configuration Cluster Server Init * * Server Init @@ -9684,7 +8662,7 @@ void emberAfBallastConfigurationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBallastConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9702,11 +8680,8 @@ void emberAfBallastConfigurationClusterServerManufacturerSpecificAttributeChange * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBallastConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBallastConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ballast Configuration Cluster Server Pre Attribute Changed * @@ -9718,11 +8693,9 @@ void emberAfBallastConfigurationClusterServerMessageSentCallback(EmberOutgoingMe * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBallastConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBallastConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Ballast Configuration Cluster Server Tick * * Server Tick @@ -9743,8 +8716,7 @@ void emberAfBallastConfigurationClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIllumMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIllumMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Illuminance Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -9754,9 +8726,7 @@ void emberAfIllumMeasurementClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIllumMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIllumMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Illuminance Measurement Cluster Client Init * * Client Init @@ -9770,7 +8740,7 @@ void emberAfIllumMeasurementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIllumMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9788,11 +8758,8 @@ void emberAfIllumMeasurementClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIllumMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIllumMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Illuminance Measurement Cluster Client Pre Attribute Changed * @@ -9804,11 +8771,9 @@ void emberAfIllumMeasurementClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIllumMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIllumMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Illuminance Measurement Cluster Client Tick * * Client Tick @@ -9823,8 +8788,7 @@ void emberAfIllumMeasurementClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIllumMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIllumMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Illuminance Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -9834,9 +8798,7 @@ void emberAfIllumMeasurementClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIllumMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIllumMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Illuminance Measurement Cluster Server Init * * Server Init @@ -9850,7 +8812,7 @@ void emberAfIllumMeasurementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIllumMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9868,11 +8830,8 @@ void emberAfIllumMeasurementClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIllumMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIllumMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Illuminance Measurement Cluster Server Pre Attribute Changed * @@ -9884,11 +8843,9 @@ void emberAfIllumMeasurementClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIllumMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIllumMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Illuminance Measurement Cluster Server Tick * * Server Tick @@ -9909,8 +8866,7 @@ void emberAfIllumMeasurementClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIllumLevelSensingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIllumLevelSensingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Illuminance Level Sensing Cluster Client Default Response * * This function is called when the client receives the default response from @@ -9920,9 +8876,7 @@ void emberAfIllumLevelSensingClusterClientAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIllumLevelSensingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIllumLevelSensingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Illuminance Level Sensing Cluster Client Init * * Client Init @@ -9936,7 +8890,7 @@ void emberAfIllumLevelSensingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIllumLevelSensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -9954,11 +8908,8 @@ void emberAfIllumLevelSensingClusterClientManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIllumLevelSensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIllumLevelSensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Illuminance Level Sensing Cluster Client Pre Attribute Changed * @@ -9970,11 +8921,9 @@ void emberAfIllumLevelSensingClusterClientMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIllumLevelSensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIllumLevelSensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Illuminance Level Sensing Cluster Client Tick * * Client Tick @@ -9989,8 +8938,7 @@ void emberAfIllumLevelSensingClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIllumLevelSensingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIllumLevelSensingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Illuminance Level Sensing Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10000,9 +8948,7 @@ void emberAfIllumLevelSensingClusterServerAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIllumLevelSensingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIllumLevelSensingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Illuminance Level Sensing Cluster Server Init * * Server Init @@ -10016,7 +8962,7 @@ void emberAfIllumLevelSensingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIllumLevelSensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10034,11 +8980,8 @@ void emberAfIllumLevelSensingClusterServerManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIllumLevelSensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIllumLevelSensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Illuminance Level Sensing Cluster Server Pre Attribute Changed * @@ -10050,11 +8993,9 @@ void emberAfIllumLevelSensingClusterServerMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIllumLevelSensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIllumLevelSensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Illuminance Level Sensing Cluster Server Tick * * Server Tick @@ -10075,8 +9016,7 @@ void emberAfIllumLevelSensingClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTempMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTempMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Temperature Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -10086,9 +9026,7 @@ void emberAfTempMeasurementClusterClientAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTempMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTempMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Temperature Measurement Cluster Client Init * * Client Init @@ -10102,7 +9040,7 @@ void emberAfTempMeasurementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfTempMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10120,11 +9058,8 @@ void emberAfTempMeasurementClusterClientManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTempMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfTempMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Temperature Measurement Cluster Client Pre Attribute Changed * @@ -10136,11 +9071,9 @@ void emberAfTempMeasurementClusterClientMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTempMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTempMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Temperature Measurement Cluster Client Tick * * Client Tick @@ -10155,8 +9088,7 @@ void emberAfTempMeasurementClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTempMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTempMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Temperature Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10166,9 +9098,7 @@ void emberAfTempMeasurementClusterServerAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTempMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTempMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Temperature Measurement Cluster Server Init * * Server Init @@ -10182,7 +9112,7 @@ void emberAfTempMeasurementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfTempMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10200,11 +9130,8 @@ void emberAfTempMeasurementClusterServerManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTempMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfTempMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Temperature Measurement Cluster Server Pre Attribute Changed * @@ -10216,11 +9143,9 @@ void emberAfTempMeasurementClusterServerMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTempMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTempMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Temperature Measurement Cluster Server Tick * * Server Tick @@ -10241,8 +9166,7 @@ void emberAfTempMeasurementClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPressureMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPressureMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Pressure Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -10252,9 +9176,7 @@ void emberAfPressureMeasurementClusterClientAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPressureMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPressureMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Pressure Measurement Cluster Client Init * * Client Init @@ -10268,7 +9190,7 @@ void emberAfPressureMeasurementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfPressureMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10286,11 +9208,8 @@ void emberAfPressureMeasurementClusterClientManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPressureMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPressureMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Pressure Measurement Cluster Client Pre Attribute Changed * @@ -10302,11 +9221,9 @@ void emberAfPressureMeasurementClusterClientMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPressureMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPressureMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Pressure Measurement Cluster Client Tick * * Client Tick @@ -10321,8 +9238,7 @@ void emberAfPressureMeasurementClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPressureMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPressureMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Pressure Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10332,9 +9248,7 @@ void emberAfPressureMeasurementClusterServerAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPressureMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPressureMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Pressure Measurement Cluster Server Init * * Server Init @@ -10348,7 +9262,7 @@ void emberAfPressureMeasurementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfPressureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10366,11 +9280,8 @@ void emberAfPressureMeasurementClusterServerManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPressureMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPressureMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Pressure Measurement Cluster Server Pre Attribute Changed * @@ -10382,11 +9293,9 @@ void emberAfPressureMeasurementClusterServerMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPressureMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPressureMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Pressure Measurement Cluster Server Tick * * Server Tick @@ -10407,8 +9316,7 @@ void emberAfPressureMeasurementClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFlowMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFlowMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Flow Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -10418,9 +9326,7 @@ void emberAfFlowMeasurementClusterClientAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFlowMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfFlowMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Flow Measurement Cluster Client Init * * Client Init @@ -10434,7 +9340,7 @@ void emberAfFlowMeasurementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfFlowMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10452,11 +9358,8 @@ void emberAfFlowMeasurementClusterClientManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfFlowMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfFlowMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Flow Measurement Cluster Client Pre Attribute Changed * @@ -10468,11 +9371,9 @@ void emberAfFlowMeasurementClusterClientMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFlowMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFlowMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Flow Measurement Cluster Client Tick * * Client Tick @@ -10487,8 +9388,7 @@ void emberAfFlowMeasurementClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFlowMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFlowMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Flow Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10498,9 +9398,7 @@ void emberAfFlowMeasurementClusterServerAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFlowMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfFlowMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Flow Measurement Cluster Server Init * * Server Init @@ -10514,7 +9412,7 @@ void emberAfFlowMeasurementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfFlowMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10532,11 +9430,8 @@ void emberAfFlowMeasurementClusterServerManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfFlowMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfFlowMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Flow Measurement Cluster Server Pre Attribute Changed * @@ -10548,11 +9443,9 @@ void emberAfFlowMeasurementClusterServerMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFlowMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFlowMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Flow Measurement Cluster Server Tick * * Server Tick @@ -10573,8 +9466,7 @@ void emberAfFlowMeasurementClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfRelativeHumidityMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Relative Humidity Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -10584,8 +9476,7 @@ void emberAfRelativeHumidityMeasurementClusterClientAttributeChangedCallback(uin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfRelativeHumidityMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Relative Humidity Measurement Cluster Client Init * @@ -10600,7 +9491,7 @@ void emberAfRelativeHumidityMeasurementClusterClientInitCallback(uint8_t endpoin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfRelativeHumidityMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10618,12 +9509,9 @@ void emberAfRelativeHumidityMeasurementClusterClientManufacturerSpecificAttribut * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfRelativeHumidityMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Relative Humidity Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -10637,8 +9525,7 @@ void emberAfRelativeHumidityMeasurementClusterClientMessageSentCallback(EmberOut EmberAfStatus emberAfRelativeHumidityMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Relative Humidity Measurement Cluster Client Tick * * Client Tick @@ -10653,8 +9540,7 @@ void emberAfRelativeHumidityMeasurementClusterClientTickCallback(uint8_t endpoin * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Relative Humidity Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10664,8 +9550,7 @@ void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(uin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfRelativeHumidityMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Relative Humidity Measurement Cluster Server Init * @@ -10680,7 +9565,7 @@ void emberAfRelativeHumidityMeasurementClusterServerInitCallback(uint8_t endpoin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfRelativeHumidityMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10698,12 +9583,9 @@ void emberAfRelativeHumidityMeasurementClusterServerManufacturerSpecificAttribut * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Relative Humidity Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -10717,8 +9599,7 @@ void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(EmberOut EmberAfStatus emberAfRelativeHumidityMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Relative Humidity Measurement Cluster Server Tick * * Server Tick @@ -10739,8 +9620,7 @@ void emberAfRelativeHumidityMeasurementClusterServerTickCallback(uint8_t endpoin * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOccupancySensingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOccupancySensingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Occupancy Sensing Cluster Client Default Response * * This function is called when the client receives the default response from @@ -10750,9 +9630,7 @@ void emberAfOccupancySensingClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOccupancySensingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOccupancySensingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Occupancy Sensing Cluster Client Init * * Client Init @@ -10766,7 +9644,7 @@ void emberAfOccupancySensingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOccupancySensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10784,11 +9662,8 @@ void emberAfOccupancySensingClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOccupancySensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOccupancySensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Occupancy Sensing Cluster Client Pre Attribute Changed * @@ -10800,11 +9675,9 @@ void emberAfOccupancySensingClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOccupancySensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOccupancySensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Occupancy Sensing Cluster Client Tick * * Client Tick @@ -10819,8 +9692,7 @@ void emberAfOccupancySensingClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOccupancySensingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOccupancySensingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Occupancy Sensing Cluster Server Default Response * * This function is called when the server receives the default response from @@ -10830,9 +9702,7 @@ void emberAfOccupancySensingClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOccupancySensingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOccupancySensingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Occupancy Sensing Cluster Server Init * * Server Init @@ -10846,7 +9716,7 @@ void emberAfOccupancySensingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOccupancySensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -10864,11 +9734,8 @@ void emberAfOccupancySensingClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOccupancySensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOccupancySensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Occupancy Sensing Cluster Server Pre Attribute Changed * @@ -10880,11 +9747,9 @@ void emberAfOccupancySensingClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOccupancySensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOccupancySensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Occupancy Sensing Cluster Server Tick * * Server Tick @@ -10916,8 +9781,7 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterClientAttributeChangedC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCarbonMonoxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Carbon Monoxide Concentration Measurement Cluster Client Init * @@ -10932,12 +9796,11 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterClientInitCallback(uint * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCarbonMonoxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Carbon Monoxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -10952,10 +9815,8 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterClientManufacturerSpeci */ void emberAfCarbonMonoxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Carbon Monoxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -10966,11 +9827,8 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterClientMessageSentCallba * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Carbon Monoxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -10996,8 +9854,7 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterServerAttributeChangedC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCarbonMonoxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Carbon Monoxide Concentration Measurement Cluster Server Init * @@ -11012,12 +9869,11 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterServerInitCallback(uint * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCarbonMonoxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Carbon Monoxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11032,10 +9888,8 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterServerManufacturerSpeci */ void emberAfCarbonMonoxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Carbon Monoxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -11046,11 +9900,8 @@ void emberAfCarbonMonoxideConcentrationMeasurementClusterServerMessageSentCallba * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Carbon Monoxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -11082,8 +9933,7 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterClientAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCarbonDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCarbonDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Carbon Dioxide Concentration Measurement Cluster Client Init * @@ -11098,12 +9948,11 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterClientInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCarbonDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfCarbonDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Carbon Dioxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11118,10 +9967,8 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterClientManufacturerSpecif */ void emberAfCarbonDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Carbon Dioxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -11132,11 +9979,8 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterClientMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Carbon Dioxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -11162,8 +10006,7 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterServerAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCarbonDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCarbonDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Carbon Dioxide Concentration Measurement Cluster Server Init * @@ -11178,12 +10021,11 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterServerInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCarbonDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfCarbonDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Carbon Dioxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11198,10 +10040,8 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterServerManufacturerSpecif */ void emberAfCarbonDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Carbon Dioxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -11212,11 +10052,8 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterServerMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Carbon Dioxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -11237,8 +10074,7 @@ void emberAfCarbonDioxideConcentrationMeasurementClusterServerTickCallback(uint8 * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEthyleneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ethylene Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -11248,8 +10084,7 @@ void emberAfEthyleneConcentrationMeasurementClusterClientAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfEthyleneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ethylene Concentration Measurement Cluster Client Init * @@ -11264,12 +10099,11 @@ void emberAfEthyleneConcentrationMeasurementClusterClientInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfEthyleneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Ethylene Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11283,10 +10117,8 @@ void emberAfEthyleneConcentrationMeasurementClusterClientManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfEthyleneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ethylene Concentration Measurement Cluster Client Pre Attribute Changed * @@ -11301,8 +10133,7 @@ void emberAfEthyleneConcentrationMeasurementClusterClientMessageSentCallback(Emb EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Ethylene Concentration Measurement Cluster Client Tick * * Client Tick @@ -11317,8 +10148,7 @@ void emberAfEthyleneConcentrationMeasurementClusterClientTickCallback(uint8_t en * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEthyleneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ethylene Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -11328,8 +10158,7 @@ void emberAfEthyleneConcentrationMeasurementClusterServerAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfEthyleneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ethylene Concentration Measurement Cluster Server Init * @@ -11344,12 +10173,11 @@ void emberAfEthyleneConcentrationMeasurementClusterServerInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEthyleneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfEthyleneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Ethylene Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11363,10 +10191,8 @@ void emberAfEthyleneConcentrationMeasurementClusterServerManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfEthyleneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ethylene Concentration Measurement Cluster Server Pre Attribute Changed * @@ -11381,8 +10207,7 @@ void emberAfEthyleneConcentrationMeasurementClusterServerMessageSentCallback(Emb EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Ethylene Concentration Measurement Cluster Server Tick * * Server Tick @@ -11414,8 +10239,7 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterClientAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEthyleneOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfEthyleneOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ethylene Oxide Concentration Measurement Cluster Client Init * @@ -11430,12 +10254,11 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterClientInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEthyleneOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfEthyleneOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Ethylene Oxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11450,10 +10273,8 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterClientManufacturerSpecif */ void emberAfEthyleneOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Ethylene Oxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -11464,11 +10285,8 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterClientMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Ethylene Oxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -11494,8 +10312,7 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterServerAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEthyleneOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfEthyleneOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ethylene Oxide Concentration Measurement Cluster Server Init * @@ -11510,12 +10327,11 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterServerInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEthyleneOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfEthyleneOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Ethylene Oxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11530,10 +10346,8 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterServerManufacturerSpecif */ void emberAfEthyleneOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Ethylene Oxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -11544,11 +10358,8 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterServerMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Ethylene Oxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -11569,8 +10380,7 @@ void emberAfEthyleneOxideConcentrationMeasurementClusterServerTickCallback(uint8 * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfHydrogenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Hydrogen Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -11580,8 +10390,7 @@ void emberAfHydrogenConcentrationMeasurementClusterClientAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHydrogenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Hydrogen Concentration Measurement Cluster Client Init * @@ -11596,12 +10405,11 @@ void emberAfHydrogenConcentrationMeasurementClusterClientInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHydrogenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Hydrogen Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11615,10 +10423,8 @@ void emberAfHydrogenConcentrationMeasurementClusterClientManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfHydrogenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Hydrogen Concentration Measurement Cluster Client Pre Attribute Changed * @@ -11633,8 +10439,7 @@ void emberAfHydrogenConcentrationMeasurementClusterClientMessageSentCallback(Emb EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Hydrogen Concentration Measurement Cluster Client Tick * * Client Tick @@ -11649,8 +10454,7 @@ void emberAfHydrogenConcentrationMeasurementClusterClientTickCallback(uint8_t en * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfHydrogenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Hydrogen Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -11660,8 +10464,7 @@ void emberAfHydrogenConcentrationMeasurementClusterServerAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHydrogenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Hydrogen Concentration Measurement Cluster Server Init * @@ -11676,12 +10479,11 @@ void emberAfHydrogenConcentrationMeasurementClusterServerInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHydrogenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHydrogenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Hydrogen Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11695,10 +10497,8 @@ void emberAfHydrogenConcentrationMeasurementClusterServerManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfHydrogenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Hydrogen Concentration Measurement Cluster Server Pre Attribute Changed * @@ -11713,8 +10513,7 @@ void emberAfHydrogenConcentrationMeasurementClusterServerMessageSentCallback(Emb EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Hydrogen Concentration Measurement Cluster Server Tick * * Server Tick @@ -11746,8 +10545,7 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterClientAttributeChange * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHydrogenSulphideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Init * @@ -11762,12 +10560,11 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterClientInitCallback(ui * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHydrogenSulphideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11782,10 +10579,8 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterClientManufacturerSpe */ void emberAfHydrogenSulphideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -11796,11 +10591,8 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterClientMessageSentCall * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Tick * * Client Tick @@ -11826,8 +10618,7 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterServerAttributeChange * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHydrogenSulphideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Init * @@ -11842,12 +10633,11 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterServerInitCallback(ui * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHydrogenSulphideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -11862,10 +10652,8 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterServerManufacturerSpe */ void emberAfHydrogenSulphideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -11876,11 +10664,8 @@ void emberAfHydrogenSulphideConcentrationMeasurementClusterServerMessageSentCall * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Tick * * Server Tick @@ -11912,8 +10697,7 @@ void emberAfNitricOxideConcentrationMeasurementClusterClientAttributeChangedCall * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfNitricOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfNitricOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Nitric Oxide Concentration Measurement Cluster Client Init * @@ -11928,12 +10712,11 @@ void emberAfNitricOxideConcentrationMeasurementClusterClientInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfNitricOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfNitricOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Nitric Oxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -11948,10 +10731,8 @@ void emberAfNitricOxideConcentrationMeasurementClusterClientManufacturerSpecific */ void emberAfNitricOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Nitric Oxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -11965,8 +10746,7 @@ void emberAfNitricOxideConcentrationMeasurementClusterClientMessageSentCallback( EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Nitric Oxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -11992,8 +10772,7 @@ void emberAfNitricOxideConcentrationMeasurementClusterServerAttributeChangedCall * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfNitricOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfNitricOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Nitric Oxide Concentration Measurement Cluster Server Init * @@ -12008,12 +10787,11 @@ void emberAfNitricOxideConcentrationMeasurementClusterServerInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfNitricOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfNitricOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Nitric Oxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -12028,10 +10806,8 @@ void emberAfNitricOxideConcentrationMeasurementClusterServerManufacturerSpecific */ void emberAfNitricOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Nitric Oxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12045,8 +10821,7 @@ void emberAfNitricOxideConcentrationMeasurementClusterServerMessageSentCallback( EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Nitric Oxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -12078,8 +10853,7 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterClientAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfNitrogenDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Init * @@ -12094,12 +10868,11 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterClientInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfNitrogenDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -12114,10 +10887,8 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterClientManufacturerSpec */ void emberAfNitrogenDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12128,11 +10899,8 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterClientMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -12158,8 +10926,7 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfNitrogenDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Init * @@ -12174,12 +10941,11 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfNitrogenDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -12194,10 +10960,8 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerManufacturerSpec */ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12208,11 +10972,8 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -12233,8 +10994,7 @@ void emberAfNitrogenDioxideConcentrationMeasurementClusterServerTickCallback(uin * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Oxygen Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -12244,8 +11004,7 @@ void emberAfOxygenConcentrationMeasurementClusterClientAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Oxygen Concentration Measurement Cluster Client Init * @@ -12260,7 +11019,7 @@ void emberAfOxygenConcentrationMeasurementClusterClientInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -12279,11 +11038,8 @@ void emberAfOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Oxygen Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12297,8 +11053,7 @@ void emberAfOxygenConcentrationMeasurementClusterClientMessageSentCallback(Ember EmberAfStatus emberAfOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Oxygen Concentration Measurement Cluster Client Tick * * Client Tick @@ -12313,8 +11068,7 @@ void emberAfOxygenConcentrationMeasurementClusterClientTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Oxygen Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -12324,8 +11078,7 @@ void emberAfOxygenConcentrationMeasurementClusterServerAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Oxygen Concentration Measurement Cluster Server Init * @@ -12340,7 +11093,7 @@ void emberAfOxygenConcentrationMeasurementClusterServerInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -12359,11 +11112,8 @@ void emberAfOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Oxygen Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12377,8 +11127,7 @@ void emberAfOxygenConcentrationMeasurementClusterServerMessageSentCallback(Ember EmberAfStatus emberAfOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Oxygen Concentration Measurement Cluster Server Tick * * Server Tick @@ -12399,8 +11148,7 @@ void emberAfOxygenConcentrationMeasurementClusterServerTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOzoneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOzoneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ozone Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -12410,8 +11158,7 @@ void emberAfOzoneConcentrationMeasurementClusterClientAttributeChangedCallback(u * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOzoneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfOzoneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ozone Concentration Measurement Cluster Client Init * @@ -12426,7 +11173,7 @@ void emberAfOzoneConcentrationMeasurementClusterClientInitCallback(uint8_t endpo * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOzoneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -12445,11 +11192,8 @@ void emberAfOzoneConcentrationMeasurementClusterClientManufacturerSpecificAttrib * @param status The status of the sent message Ver.: always */ void emberAfOzoneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ozone Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12463,8 +11207,7 @@ void emberAfOzoneConcentrationMeasurementClusterClientMessageSentCallback(EmberO EmberAfStatus emberAfOzoneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Ozone Concentration Measurement Cluster Client Tick * * Client Tick @@ -12479,8 +11222,7 @@ void emberAfOzoneConcentrationMeasurementClusterClientTickCallback(uint8_t endpo * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Ozone Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -12490,8 +11232,7 @@ void emberAfOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(u * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOzoneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfOzoneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Ozone Concentration Measurement Cluster Server Init * @@ -12506,7 +11247,7 @@ void emberAfOzoneConcentrationMeasurementClusterServerInitCallback(uint8_t endpo * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOzoneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -12525,11 +11266,8 @@ void emberAfOzoneConcentrationMeasurementClusterServerManufacturerSpecificAttrib * @param status The status of the sent message Ver.: always */ void emberAfOzoneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Ozone Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12543,8 +11281,7 @@ void emberAfOzoneConcentrationMeasurementClusterServerMessageSentCallback(EmberO EmberAfStatus emberAfOzoneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Ozone Concentration Measurement Cluster Server Tick * * Server Tick @@ -12576,8 +11313,7 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterClientAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSulfurDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSulfurDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sulfur Dioxide Concentration Measurement Cluster Client Init * @@ -12592,12 +11328,11 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterClientInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSulfurDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfSulfurDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Sulfur Dioxide Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -12612,10 +11347,8 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterClientManufacturerSpecif */ void emberAfSulfurDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Sulfur Dioxide Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12626,11 +11359,8 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterClientMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Sulfur Dioxide Concentration Measurement Cluster Client Tick * * Client Tick @@ -12656,8 +11386,7 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterServerAttributeChangedCa * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSulfurDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSulfurDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sulfur Dioxide Concentration Measurement Cluster Server Init * @@ -12672,12 +11401,11 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterServerInitCallback(uint8 * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSulfurDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfSulfurDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Sulfur Dioxide Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -12692,10 +11420,8 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterServerManufacturerSpecif */ void emberAfSulfurDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Sulfur Dioxide Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12706,11 +11432,8 @@ void emberAfSulfurDioxideConcentrationMeasurementClusterServerMessageSentCallbac * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Sulfur Dioxide Concentration Measurement Cluster Server Tick * * Server Tick @@ -12742,8 +11465,7 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterClientAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDissolvedOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Dissolved Oxygen Concentration Measurement Cluster Client Init * @@ -12758,12 +11480,11 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterClientInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDissolvedOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Dissolved Oxygen Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -12778,10 +11499,8 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterClientManufacturerSpec */ void emberAfDissolvedOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Dissolved Oxygen Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12792,11 +11511,8 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterClientMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Dissolved Oxygen Concentration Measurement Cluster Client Tick * * Client Tick @@ -12822,8 +11538,7 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDissolvedOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Dissolved Oxygen Concentration Measurement Cluster Server Init * @@ -12838,12 +11553,11 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDissolvedOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Dissolved Oxygen Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -12858,10 +11572,8 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerManufacturerSpec */ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Dissolved Oxygen Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -12872,11 +11584,8 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Dissolved Oxygen Concentration Measurement Cluster Server Tick * * Server Tick @@ -12897,8 +11606,7 @@ void emberAfDissolvedOxygenConcentrationMeasurementClusterServerTickCallback(uin * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBromateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBromateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Bromate Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -12908,8 +11616,7 @@ void emberAfBromateConcentrationMeasurementClusterClientAttributeChangedCallback * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromate Concentration Measurement Cluster Client Init * @@ -12924,7 +11631,7 @@ void emberAfBromateConcentrationMeasurementClusterClientInitCallback(uint8_t end * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBromateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -12943,11 +11650,8 @@ void emberAfBromateConcentrationMeasurementClusterClientManufacturerSpecificAttr * @param status The status of the sent message Ver.: always */ void emberAfBromateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Bromate Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -12961,8 +11665,7 @@ void emberAfBromateConcentrationMeasurementClusterClientMessageSentCallback(Embe EmberAfStatus emberAfBromateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Bromate Concentration Measurement Cluster Client Tick * * Client Tick @@ -12977,8 +11680,7 @@ void emberAfBromateConcentrationMeasurementClusterClientTickCallback(uint8_t end * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBromateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBromateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Bromate Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -12988,8 +11690,7 @@ void emberAfBromateConcentrationMeasurementClusterServerAttributeChangedCallback * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromate Concentration Measurement Cluster Server Init * @@ -13004,7 +11705,7 @@ void emberAfBromateConcentrationMeasurementClusterServerInitCallback(uint8_t end * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBromateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -13023,11 +11724,8 @@ void emberAfBromateConcentrationMeasurementClusterServerManufacturerSpecificAttr * @param status The status of the sent message Ver.: always */ void emberAfBromateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Bromate Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -13041,8 +11739,7 @@ void emberAfBromateConcentrationMeasurementClusterServerMessageSentCallback(Embe EmberAfStatus emberAfBromateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Bromate Concentration Measurement Cluster Server Tick * * Server Tick @@ -13074,8 +11771,7 @@ void emberAfChloraminesConcentrationMeasurementClusterClientAttributeChangedCall * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChloraminesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChloraminesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chloramines Concentration Measurement Cluster Client Init * @@ -13090,12 +11786,11 @@ void emberAfChloraminesConcentrationMeasurementClusterClientInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChloraminesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChloraminesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chloramines Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13110,10 +11805,8 @@ void emberAfChloraminesConcentrationMeasurementClusterClientManufacturerSpecific */ void emberAfChloraminesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chloramines Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -13127,8 +11820,7 @@ void emberAfChloraminesConcentrationMeasurementClusterClientMessageSentCallback( EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chloramines Concentration Measurement Cluster Client Tick * * Client Tick @@ -13154,8 +11846,7 @@ void emberAfChloraminesConcentrationMeasurementClusterServerAttributeChangedCall * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChloraminesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChloraminesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chloramines Concentration Measurement Cluster Server Init * @@ -13170,12 +11861,11 @@ void emberAfChloraminesConcentrationMeasurementClusterServerInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChloraminesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChloraminesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chloramines Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -13190,10 +11880,8 @@ void emberAfChloraminesConcentrationMeasurementClusterServerManufacturerSpecific */ void emberAfChloraminesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chloramines Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -13207,8 +11895,7 @@ void emberAfChloraminesConcentrationMeasurementClusterServerMessageSentCallback( EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chloramines Concentration Measurement Cluster Server Tick * * Server Tick @@ -13229,8 +11916,7 @@ void emberAfChloraminesConcentrationMeasurementClusterServerTickCallback(uint8_t * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfChlorineConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Chlorine Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -13240,8 +11926,7 @@ void emberAfChlorineConcentrationMeasurementClusterClientAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChlorineConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chlorine Concentration Measurement Cluster Client Init * @@ -13256,12 +11941,11 @@ void emberAfChlorineConcentrationMeasurementClusterClientInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChlorineConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chlorine Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13275,10 +11959,8 @@ void emberAfChlorineConcentrationMeasurementClusterClientManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfChlorineConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Chlorine Concentration Measurement Cluster Client Pre Attribute Changed * @@ -13293,8 +11975,7 @@ void emberAfChlorineConcentrationMeasurementClusterClientMessageSentCallback(Emb EmberAfStatus emberAfChlorineConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chlorine Concentration Measurement Cluster Client Tick * * Client Tick @@ -13309,8 +11990,7 @@ void emberAfChlorineConcentrationMeasurementClusterClientTickCallback(uint8_t en * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfChlorineConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Chlorine Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -13320,8 +12000,7 @@ void emberAfChlorineConcentrationMeasurementClusterServerAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChlorineConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chlorine Concentration Measurement Cluster Server Init * @@ -13336,12 +12015,11 @@ void emberAfChlorineConcentrationMeasurementClusterServerInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChlorineConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChlorineConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chlorine Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -13355,10 +12033,8 @@ void emberAfChlorineConcentrationMeasurementClusterServerManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfChlorineConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Chlorine Concentration Measurement Cluster Server Pre Attribute Changed * @@ -13373,8 +12049,7 @@ void emberAfChlorineConcentrationMeasurementClusterServerMessageSentCallback(Emb EmberAfStatus emberAfChlorineConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chlorine Concentration Measurement Cluster Server Tick * * Server Tick @@ -13406,8 +12081,7 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientAttributeC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Init * @@ -13422,12 +12096,11 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientInitCallba * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13442,10 +12115,8 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientManufactur */ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -13456,11 +12127,8 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientMessageSen * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Tick * * Client Tick @@ -13486,8 +12154,7 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerAttributeC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Init * @@ -13502,12 +12169,11 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerInitCallba * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -13522,10 +12188,8 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerManufactur */ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -13536,11 +12200,8 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerMessageSen * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Tick * * Server Tick @@ -13561,8 +12222,7 @@ void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerTickCallba * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFluorideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Fluoride Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -13572,8 +12232,7 @@ void emberAfFluorideConcentrationMeasurementClusterClientAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfFluorideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fluoride Concentration Measurement Cluster Client Init * @@ -13588,12 +12247,11 @@ void emberAfFluorideConcentrationMeasurementClusterClientInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfFluorideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fluoride Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13607,10 +12265,8 @@ void emberAfFluorideConcentrationMeasurementClusterClientManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfFluorideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Fluoride Concentration Measurement Cluster Client Pre Attribute Changed * @@ -13625,8 +12281,7 @@ void emberAfFluorideConcentrationMeasurementClusterClientMessageSentCallback(Emb EmberAfStatus emberAfFluorideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Fluoride Concentration Measurement Cluster Client Tick * * Client Tick @@ -13641,8 +12296,7 @@ void emberAfFluorideConcentrationMeasurementClusterClientTickCallback(uint8_t en * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfFluorideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Fluoride Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -13652,8 +12306,7 @@ void emberAfFluorideConcentrationMeasurementClusterServerAttributeChangedCallbac * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfFluorideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Fluoride Concentration Measurement Cluster Server Init * @@ -13668,12 +12321,11 @@ void emberAfFluorideConcentrationMeasurementClusterServerInitCallback(uint8_t en * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfFluorideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfFluorideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Fluoride Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -13687,10 +12339,8 @@ void emberAfFluorideConcentrationMeasurementClusterServerManufacturerSpecificAtt * @param status The status of the sent message Ver.: always */ void emberAfFluorideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Fluoride Concentration Measurement Cluster Server Pre Attribute Changed * @@ -13705,8 +12355,7 @@ void emberAfFluorideConcentrationMeasurementClusterServerMessageSentCallback(Emb EmberAfStatus emberAfFluorideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Fluoride Concentration Measurement Cluster Server Tick * * Server Tick @@ -13738,8 +12387,7 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Haloacetic Acids Concentration Measurement Cluster Client Init * @@ -13754,12 +12402,11 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Haloacetic Acids Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13774,10 +12421,8 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientManufacturerSpec */ void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Haloacetic Acids Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -13788,11 +12433,8 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Haloacetic Acids Concentration Measurement Cluster Client Tick * * Client Tick @@ -13818,8 +12460,7 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerAttributeChanged * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Haloacetic Acids Concentration Measurement Cluster Server Init * @@ -13834,12 +12475,11 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerInitCallback(uin * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Haloacetic Acids Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -13854,10 +12494,8 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerManufacturerSpec */ void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Haloacetic Acids Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -13868,11 +12506,8 @@ void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerMessageSentCallb * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Haloacetic Acids Concentration Measurement Cluster Server Tick * * Server Tick @@ -13904,8 +12539,7 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Total Trihalomethanes Concentration Measurement Cluster Client Init * @@ -13920,12 +12554,11 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Total Trihalomethanes Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -13940,10 +12573,8 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientManufacture */ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Total Trihalomethanes Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -13954,11 +12585,8 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Total Trihalomethanes Concentration Measurement Cluster Client Tick * * Client Tick @@ -13984,8 +12612,7 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Total Trihalomethanes Concentration Measurement Cluster Server Init * @@ -14000,12 +12627,11 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Total Trihalomethanes Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -14020,10 +12646,8 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerManufacture */ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Total Trihalomethanes Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -14034,11 +12658,8 @@ void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Total Trihalomethanes Concentration Measurement Cluster Server Tick * * Server Tick @@ -14070,8 +12691,7 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientAttributeC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Init * @@ -14086,12 +12706,11 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientInitCallba * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -14106,10 +12725,8 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientManufactur */ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -14120,11 +12737,8 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientMessageSen * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Tick * * Client Tick @@ -14150,8 +12764,7 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerAttributeC * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Init * @@ -14166,12 +12779,11 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerInitCallba * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -14186,10 +12798,8 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerManufactur */ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -14200,11 +12810,8 @@ void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerMessageSen * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Tick * * Server Tick @@ -14236,8 +12843,7 @@ void emberAfTurbidityConcentrationMeasurementClusterClientAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTurbidityConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTurbidityConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Turbidity Concentration Measurement Cluster Client Init * @@ -14252,12 +12858,11 @@ void emberAfTurbidityConcentrationMeasurementClusterClientInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTurbidityConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTurbidityConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Turbidity Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -14271,10 +12876,8 @@ void emberAfTurbidityConcentrationMeasurementClusterClientManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfTurbidityConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Turbidity Concentration Measurement Cluster Client Pre Attribute Changed * @@ -14289,8 +12892,7 @@ void emberAfTurbidityConcentrationMeasurementClusterClientMessageSentCallback(Em EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Turbidity Concentration Measurement Cluster Client Tick * * Client Tick @@ -14316,8 +12918,7 @@ void emberAfTurbidityConcentrationMeasurementClusterServerAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTurbidityConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfTurbidityConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Turbidity Concentration Measurement Cluster Server Init * @@ -14332,12 +12933,11 @@ void emberAfTurbidityConcentrationMeasurementClusterServerInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTurbidityConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfTurbidityConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Turbidity Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -14351,10 +12951,8 @@ void emberAfTurbidityConcentrationMeasurementClusterServerManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfTurbidityConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Turbidity Concentration Measurement Cluster Server Pre Attribute Changed * @@ -14369,8 +12967,7 @@ void emberAfTurbidityConcentrationMeasurementClusterServerMessageSentCallback(Em EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Turbidity Concentration Measurement Cluster Server Tick * * Server Tick @@ -14391,8 +12988,7 @@ void emberAfTurbidityConcentrationMeasurementClusterServerTickCallback(uint8_t e * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCopperConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCopperConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Copper Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -14402,8 +12998,7 @@ void emberAfCopperConcentrationMeasurementClusterClientAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCopperConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCopperConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Copper Concentration Measurement Cluster Client Init * @@ -14418,7 +13013,7 @@ void emberAfCopperConcentrationMeasurementClusterClientInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfCopperConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -14437,11 +13032,8 @@ void emberAfCopperConcentrationMeasurementClusterClientManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfCopperConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Copper Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -14455,8 +13047,7 @@ void emberAfCopperConcentrationMeasurementClusterClientMessageSentCallback(Ember EmberAfStatus emberAfCopperConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Copper Concentration Measurement Cluster Client Tick * * Client Tick @@ -14471,8 +13062,7 @@ void emberAfCopperConcentrationMeasurementClusterClientTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCopperConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCopperConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Copper Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -14482,8 +13072,7 @@ void emberAfCopperConcentrationMeasurementClusterServerAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCopperConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfCopperConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Copper Concentration Measurement Cluster Server Init * @@ -14498,7 +13087,7 @@ void emberAfCopperConcentrationMeasurementClusterServerInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfCopperConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -14517,11 +13106,8 @@ void emberAfCopperConcentrationMeasurementClusterServerManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfCopperConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Copper Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -14535,8 +13121,7 @@ void emberAfCopperConcentrationMeasurementClusterServerMessageSentCallback(Ember EmberAfStatus emberAfCopperConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Copper Concentration Measurement Cluster Server Tick * * Server Tick @@ -14557,8 +13142,7 @@ void emberAfCopperConcentrationMeasurementClusterServerTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfLeadConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Lead Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -14568,8 +13152,7 @@ void emberAfLeadConcentrationMeasurementClusterClientAttributeChangedCallback(ui * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfLeadConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Lead Concentration Measurement Cluster Client Init * @@ -14584,7 +13167,7 @@ void emberAfLeadConcentrationMeasurementClusterClientInitCallback(uint8_t endpoi * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfLeadConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -14602,12 +13185,9 @@ void emberAfLeadConcentrationMeasurementClusterClientManufacturerSpecificAttribu * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfLeadConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Lead Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -14621,8 +13201,7 @@ void emberAfLeadConcentrationMeasurementClusterClientMessageSentCallback(EmberOu EmberAfStatus emberAfLeadConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Lead Concentration Measurement Cluster Client Tick * * Client Tick @@ -14637,8 +13216,7 @@ void emberAfLeadConcentrationMeasurementClusterClientTickCallback(uint8_t endpoi * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfLeadConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Lead Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -14648,8 +13226,7 @@ void emberAfLeadConcentrationMeasurementClusterServerAttributeChangedCallback(ui * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfLeadConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Lead Concentration Measurement Cluster Server Init * @@ -14664,7 +13241,7 @@ void emberAfLeadConcentrationMeasurementClusterServerInitCallback(uint8_t endpoi * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfLeadConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -14682,12 +13259,9 @@ void emberAfLeadConcentrationMeasurementClusterServerManufacturerSpecificAttribu * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfLeadConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfLeadConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Lead Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -14701,8 +13275,7 @@ void emberAfLeadConcentrationMeasurementClusterServerMessageSentCallback(EmberOu EmberAfStatus emberAfLeadConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Lead Concentration Measurement Cluster Server Tick * * Server Tick @@ -14734,8 +13307,7 @@ void emberAfManganeseConcentrationMeasurementClusterClientAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfManganeseConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfManganeseConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Manganese Concentration Measurement Cluster Client Init * @@ -14750,12 +13322,11 @@ void emberAfManganeseConcentrationMeasurementClusterClientInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfManganeseConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfManganeseConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Manganese Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -14769,10 +13340,8 @@ void emberAfManganeseConcentrationMeasurementClusterClientManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfManganeseConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Manganese Concentration Measurement Cluster Client Pre Attribute Changed * @@ -14787,8 +13356,7 @@ void emberAfManganeseConcentrationMeasurementClusterClientMessageSentCallback(Em EmberAfStatus emberAfManganeseConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Manganese Concentration Measurement Cluster Client Tick * * Client Tick @@ -14814,8 +13382,7 @@ void emberAfManganeseConcentrationMeasurementClusterServerAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfManganeseConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfManganeseConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Manganese Concentration Measurement Cluster Server Init * @@ -14830,12 +13397,11 @@ void emberAfManganeseConcentrationMeasurementClusterServerInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfManganeseConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfManganeseConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Manganese Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -14849,10 +13415,8 @@ void emberAfManganeseConcentrationMeasurementClusterServerManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfManganeseConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Manganese Concentration Measurement Cluster Server Pre Attribute Changed * @@ -14867,8 +13431,7 @@ void emberAfManganeseConcentrationMeasurementClusterServerMessageSentCallback(Em EmberAfStatus emberAfManganeseConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Manganese Concentration Measurement Cluster Server Tick * * Server Tick @@ -14889,8 +13452,7 @@ void emberAfManganeseConcentrationMeasurementClusterServerTickCallback(uint8_t e * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSulfateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSulfateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sulfate Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -14900,8 +13462,7 @@ void emberAfSulfateConcentrationMeasurementClusterClientAttributeChangedCallback * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSulfateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSulfateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sulfate Concentration Measurement Cluster Client Init * @@ -14916,7 +13477,7 @@ void emberAfSulfateConcentrationMeasurementClusterClientInitCallback(uint8_t end * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSulfateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -14935,11 +13496,8 @@ void emberAfSulfateConcentrationMeasurementClusterClientManufacturerSpecificAttr * @param status The status of the sent message Ver.: always */ void emberAfSulfateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sulfate Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -14953,8 +13511,7 @@ void emberAfSulfateConcentrationMeasurementClusterClientMessageSentCallback(Embe EmberAfStatus emberAfSulfateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Sulfate Concentration Measurement Cluster Client Tick * * Client Tick @@ -14969,8 +13526,7 @@ void emberAfSulfateConcentrationMeasurementClusterClientTickCallback(uint8_t end * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSulfateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSulfateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sulfate Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -14980,8 +13536,7 @@ void emberAfSulfateConcentrationMeasurementClusterServerAttributeChangedCallback * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSulfateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSulfateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sulfate Concentration Measurement Cluster Server Init * @@ -14996,7 +13551,7 @@ void emberAfSulfateConcentrationMeasurementClusterServerInitCallback(uint8_t end * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSulfateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -15015,11 +13570,8 @@ void emberAfSulfateConcentrationMeasurementClusterServerManufacturerSpecificAttr * @param status The status of the sent message Ver.: always */ void emberAfSulfateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sulfate Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -15033,8 +13585,7 @@ void emberAfSulfateConcentrationMeasurementClusterServerMessageSentCallback(Embe EmberAfStatus emberAfSulfateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Sulfate Concentration Measurement Cluster Server Tick * * Server Tick @@ -15066,8 +13617,7 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterClientAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromodichloromethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromodichloromethane Concentration Measurement Cluster Client Init * @@ -15082,12 +13632,11 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterClientInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBromodichloromethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Bromodichloromethane Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -15102,10 +13651,8 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterClientManufacture */ void emberAfBromodichloromethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Bromodichloromethane Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -15116,11 +13663,8 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterClientMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Bromodichloromethane Concentration Measurement Cluster Client Tick * * Client Tick @@ -15146,8 +13690,7 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterServerAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromodichloromethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromodichloromethane Concentration Measurement Cluster Server Init * @@ -15162,12 +13705,11 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterServerInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBromodichloromethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Bromodichloromethane Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -15182,10 +13724,8 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterServerManufacture */ void emberAfBromodichloromethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Bromodichloromethane Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -15196,11 +13736,8 @@ void emberAfBromodichloromethaneConcentrationMeasurementClusterServerMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Bromodichloromethane Concentration Measurement Cluster Server Tick * * Server Tick @@ -15232,8 +13769,7 @@ void emberAfBromoformConcentrationMeasurementClusterClientAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromoformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromoformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromoform Concentration Measurement Cluster Client Init * @@ -15248,12 +13784,11 @@ void emberAfBromoformConcentrationMeasurementClusterClientInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBromoformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfBromoformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Bromoform Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -15267,10 +13802,8 @@ void emberAfBromoformConcentrationMeasurementClusterClientManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfBromoformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Bromoform Concentration Measurement Cluster Client Pre Attribute Changed * @@ -15285,8 +13818,7 @@ void emberAfBromoformConcentrationMeasurementClusterClientMessageSentCallback(Em EmberAfStatus emberAfBromoformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Bromoform Concentration Measurement Cluster Client Tick * * Client Tick @@ -15312,8 +13844,7 @@ void emberAfBromoformConcentrationMeasurementClusterServerAttributeChangedCallba * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBromoformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfBromoformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Bromoform Concentration Measurement Cluster Server Init * @@ -15328,12 +13859,11 @@ void emberAfBromoformConcentrationMeasurementClusterServerInitCallback(uint8_t e * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBromoformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfBromoformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Bromoform Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -15347,10 +13877,8 @@ void emberAfBromoformConcentrationMeasurementClusterServerManufacturerSpecificAt * @param status The status of the sent message Ver.: always */ void emberAfBromoformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Bromoform Concentration Measurement Cluster Server Pre Attribute Changed * @@ -15365,8 +13893,7 @@ void emberAfBromoformConcentrationMeasurementClusterServerMessageSentCallback(Em EmberAfStatus emberAfBromoformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Bromoform Concentration Measurement Cluster Server Tick * * Server Tick @@ -15398,8 +13925,7 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chlorodibromomethane Concentration Measurement Cluster Client Init * @@ -15414,12 +13940,11 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chlorodibromomethane Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -15434,10 +13959,8 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientManufacture */ void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chlorodibromomethane Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -15448,11 +13971,8 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Chlorodibromomethane Concentration Measurement Cluster Client Tick * * Client Tick @@ -15478,8 +13998,7 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerAttributeCh * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chlorodibromomethane Concentration Measurement Cluster Server Init * @@ -15494,12 +14013,11 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerInitCallbac * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chlorodibromomethane Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -15514,10 +14032,8 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerManufacture */ void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chlorodibromomethane Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -15528,11 +14044,8 @@ void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerMessageSent * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); /** @brief Chlorodibromomethane Concentration Measurement Cluster Server Tick * * Server Tick @@ -15564,8 +14077,7 @@ void emberAfChloroformConcentrationMeasurementClusterClientAttributeChangedCallb * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChloroformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChloroformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chloroform Concentration Measurement Cluster Client Init * @@ -15580,12 +14092,11 @@ void emberAfChloroformConcentrationMeasurementClusterClientInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChloroformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChloroformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chloroform Concentration Measurement Cluster Client Message Sent * * Client Message Sent @@ -15600,10 +14111,8 @@ void emberAfChloroformConcentrationMeasurementClusterClientManufacturerSpecificA */ void emberAfChloroformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chloroform Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -15617,8 +14126,7 @@ void emberAfChloroformConcentrationMeasurementClusterClientMessageSentCallback(E EmberAfStatus emberAfChloroformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chloroform Concentration Measurement Cluster Client Tick * * Client Tick @@ -15644,8 +14152,7 @@ void emberAfChloroformConcentrationMeasurementClusterServerAttributeChangedCallb * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChloroformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfChloroformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chloroform Concentration Measurement Cluster Server Init * @@ -15660,12 +14167,11 @@ void emberAfChloroformConcentrationMeasurementClusterServerInitCallback(uint8_t * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChloroformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - uint16_t manufacturerCode); +void emberAfChloroformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chloroform Concentration Measurement Cluster Server Message Sent * * Server Message Sent @@ -15680,10 +14186,8 @@ void emberAfChloroformConcentrationMeasurementClusterServerManufacturerSpecificA */ void emberAfChloroformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); /** @brief Chloroform Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -15697,8 +14201,7 @@ void emberAfChloroformConcentrationMeasurementClusterServerMessageSentCallback(E EmberAfStatus emberAfChloroformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Chloroform Concentration Measurement Cluster Server Tick * * Server Tick @@ -15719,8 +14222,7 @@ void emberAfChloroformConcentrationMeasurementClusterServerTickCallback(uint8_t * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSodiumConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSodiumConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sodium Concentration Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -15730,8 +14232,7 @@ void emberAfSodiumConcentrationMeasurementClusterClientAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSodiumConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSodiumConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sodium Concentration Measurement Cluster Client Init * @@ -15746,7 +14247,7 @@ void emberAfSodiumConcentrationMeasurementClusterClientInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSodiumConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -15765,11 +14266,8 @@ void emberAfSodiumConcentrationMeasurementClusterClientManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfSodiumConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sodium Concentration Measurement Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -15783,8 +14281,7 @@ void emberAfSodiumConcentrationMeasurementClusterClientMessageSentCallback(Ember EmberAfStatus emberAfSodiumConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Sodium Concentration Measurement Cluster Client Tick * * Client Tick @@ -15799,8 +14296,7 @@ void emberAfSodiumConcentrationMeasurementClusterClientTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSodiumConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSodiumConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sodium Concentration Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -15810,8 +14306,7 @@ void emberAfSodiumConcentrationMeasurementClusterServerAttributeChangedCallback( * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSodiumConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfSodiumConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sodium Concentration Measurement Cluster Server Init * @@ -15826,7 +14321,7 @@ void emberAfSodiumConcentrationMeasurementClusterServerInitCallback(uint8_t endp * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSodiumConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -15845,11 +14340,8 @@ void emberAfSodiumConcentrationMeasurementClusterServerManufacturerSpecificAttri * @param status The status of the sent message Ver.: always */ void emberAfSodiumConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sodium Concentration Measurement Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -15863,8 +14355,7 @@ void emberAfSodiumConcentrationMeasurementClusterServerMessageSentCallback(Ember EmberAfStatus emberAfSodiumConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Sodium Concentration Measurement Cluster Server Tick * * Server Tick @@ -15885,8 +14376,7 @@ void emberAfSodiumConcentrationMeasurementClusterServerTickCallback(uint8_t endp * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasZoneClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasZoneClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS Zone Cluster Client Default Response * * This function is called when the client receives the default response from @@ -15896,9 +14386,7 @@ void emberAfIasZoneClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasZoneClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasZoneClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS Zone Cluster Client Init * * Client Init @@ -15912,11 +14400,10 @@ void emberAfIasZoneClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasZoneClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasZoneClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS Zone Cluster Client Message Sent * @@ -15930,11 +14417,8 @@ void emberAfIasZoneClusterClientManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasZoneClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIasZoneClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS Zone Cluster Client Pre Attribute Changed * @@ -15946,11 +14430,9 @@ void emberAfIasZoneClusterClientMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasZoneClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasZoneClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS Zone Cluster Client Tick * * Client Tick @@ -15960,28 +14442,27 @@ EmberAfStatus emberAfIasZoneClusterClientPreAttributeChangedCallback(uint8_t end void emberAfIasZoneClusterClientTickCallback(uint8_t endpoint); /** @brief IAS Zone Cluster Initiate Normal Operation Mode * - * + * * */ bool emberAfIasZoneClusterInitiateNormalOperationModeCallback(void); /** @brief IAS Zone Cluster Initiate Normal Operation Mode Response * - * + * * */ bool emberAfIasZoneClusterInitiateNormalOperationModeResponseCallback(void); /** @brief IAS Zone Cluster Initiate Test Mode * - * + * * * @param testModeDuration Ver.: always * @param currentZoneSensitivityLevel Ver.: always */ -bool emberAfIasZoneClusterInitiateTestModeCallback(uint8_t testModeDuration, - uint8_t currentZoneSensitivityLevel); +bool emberAfIasZoneClusterInitiateTestModeCallback(uint8_t testModeDuration, uint8_t currentZoneSensitivityLevel); /** @brief IAS Zone Cluster Initiate Test Mode Response * - * + * * */ bool emberAfIasZoneClusterInitiateTestModeResponseCallback(void); @@ -15992,8 +14473,7 @@ bool emberAfIasZoneClusterInitiateTestModeResponseCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasZoneClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasZoneClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS Zone Cluster Server Default Response * * This function is called when the server receives the default response from @@ -16003,9 +14483,7 @@ void emberAfIasZoneClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasZoneClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasZoneClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS Zone Cluster Server Init * * Server Init @@ -16019,11 +14497,10 @@ void emberAfIasZoneClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS Zone Cluster Server Message Sent * @@ -16037,11 +14514,8 @@ void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS Zone Cluster Server Pre Attribute Changed * @@ -16053,11 +14527,9 @@ void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS Zone Cluster Server Tick * * Server Tick @@ -16067,35 +14539,31 @@ EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t end void emberAfIasZoneClusterServerTickCallback(uint8_t endpoint); /** @brief IAS Zone Cluster Zone Enroll Request * - * + * * * @param zoneType Ver.: always * @param manufacturerCode Ver.: always */ -bool emberAfIasZoneClusterZoneEnrollRequestCallback(uint16_t zoneType, - uint16_t manufacturerCode); +bool emberAfIasZoneClusterZoneEnrollRequestCallback(uint16_t zoneType, uint16_t manufacturerCode); /** @brief IAS Zone Cluster Zone Enroll Response * - * + * * * @param enrollResponseCode Ver.: always * @param zoneId Ver.: always */ -bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, - uint8_t zoneId); +bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, uint8_t zoneId); /** @brief IAS Zone Cluster Zone Status Change Notification * - * + * * * @param zoneStatus Ver.: always * @param extendedStatus Ver.: always * @param zoneId Ver.: since ha-1.2-05-3520-29 * @param delay Ver.: since ha-1.2-05-3520-29 */ -bool emberAfIasZoneClusterZoneStatusChangeNotificationCallback(uint16_t zoneStatus, - uint8_t extendedStatus, - uint8_t zoneId, - uint16_t delay); +bool emberAfIasZoneClusterZoneStatusChangeNotificationCallback(uint16_t zoneStatus, uint8_t extendedStatus, uint8_t zoneId, + uint16_t delay); /** @} END IAS Zone Cluster Callbacks */ @@ -16104,42 +14572,37 @@ bool emberAfIasZoneClusterZoneStatusChangeNotificationCallback(uint16_t zoneStat /** @brief IAS ACE Cluster Arm * - * + * * * @param armMode Ver.: always * @param armDisarmCode Ver.: since ha-1.2-05-3520-29 * @param zoneId Ver.: since ha-1.2-05-3520-29 */ -bool emberAfIasAceClusterArmCallback(uint8_t armMode, - uint8_t* armDisarmCode, - uint8_t zoneId); +bool emberAfIasAceClusterArmCallback(uint8_t armMode, uint8_t * armDisarmCode, uint8_t zoneId); /** @brief IAS ACE Cluster Arm Response * - * + * * * @param armNotification Ver.: always */ bool emberAfIasAceClusterArmResponseCallback(uint8_t armNotification); /** @brief IAS ACE Cluster Bypass * - * + * * * @param numberOfZones Ver.: always * @param zoneIds Ver.: always * @param armDisarmCode Ver.: since ha-1.2.1-05-3520-30 */ -bool emberAfIasAceClusterBypassCallback(uint8_t numberOfZones, - uint8_t* zoneIds, - uint8_t* armDisarmCode); +bool emberAfIasAceClusterBypassCallback(uint8_t numberOfZones, uint8_t * zoneIds, uint8_t * armDisarmCode); /** @brief IAS ACE Cluster Bypass Response * - * + * * * @param numberOfZones Ver.: always * @param bypassResult Ver.: always */ -bool emberAfIasAceClusterBypassResponseCallback(uint8_t numberOfZones, - uint8_t* bypassResult); +bool emberAfIasAceClusterBypassResponseCallback(uint8_t numberOfZones, uint8_t * bypassResult); /** @brief IAS ACE Cluster Client Attribute Changed * * Client Attribute Changed @@ -16147,8 +14610,7 @@ bool emberAfIasAceClusterBypassResponseCallback(uint8_t numberOfZones, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasAceClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasAceClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS ACE Cluster Client Default Response * * This function is called when the client receives the default response from @@ -16158,9 +14620,7 @@ void emberAfIasAceClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasAceClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasAceClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS ACE Cluster Client Init * * Client Init @@ -16174,11 +14634,10 @@ void emberAfIasAceClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasAceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasAceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS ACE Cluster Client Message Sent * @@ -16192,11 +14651,8 @@ void emberAfIasAceClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasAceClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIasAceClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS ACE Cluster Client Pre Attribute Changed * @@ -16208,11 +14664,9 @@ void emberAfIasAceClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasAceClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasAceClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS ACE Cluster Client Tick * * Client Tick @@ -16222,50 +14676,48 @@ EmberAfStatus emberAfIasAceClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfIasAceClusterClientTickCallback(uint8_t endpoint); /** @brief IAS ACE Cluster Emergency * - * + * * */ bool emberAfIasAceClusterEmergencyCallback(void); /** @brief IAS ACE Cluster Fire * - * + * * */ bool emberAfIasAceClusterFireCallback(void); /** @brief IAS ACE Cluster Get Bypassed Zone List * - * + * * */ bool emberAfIasAceClusterGetBypassedZoneListCallback(void); /** @brief IAS ACE Cluster Get Panel Status * - * + * * */ bool emberAfIasAceClusterGetPanelStatusCallback(void); /** @brief IAS ACE Cluster Get Panel Status Response * - * + * * * @param panelStatus Ver.: always * @param secondsRemaining Ver.: always * @param audibleNotification Ver.: always * @param alarmStatus Ver.: always */ -bool emberAfIasAceClusterGetPanelStatusResponseCallback(uint8_t panelStatus, - uint8_t secondsRemaining, - uint8_t audibleNotification, - uint8_t alarmStatus); +bool emberAfIasAceClusterGetPanelStatusResponseCallback(uint8_t panelStatus, uint8_t secondsRemaining, uint8_t audibleNotification, + uint8_t alarmStatus); /** @brief IAS ACE Cluster Get Zone Id Map * - * + * * */ bool emberAfIasAceClusterGetZoneIdMapCallback(void); /** @brief IAS ACE Cluster Get Zone Id Map Response * - * + * * * @param section0 Ver.: always * @param section1 Ver.: always @@ -16284,82 +14736,64 @@ bool emberAfIasAceClusterGetZoneIdMapCallback(void); * @param section14 Ver.: always * @param section15 Ver.: always */ -bool emberAfIasAceClusterGetZoneIdMapResponseCallback(uint16_t section0, - uint16_t section1, - uint16_t section2, - uint16_t section3, - uint16_t section4, - uint16_t section5, - uint16_t section6, - uint16_t section7, - uint16_t section8, - uint16_t section9, - uint16_t section10, - uint16_t section11, - uint16_t section12, - uint16_t section13, - uint16_t section14, - uint16_t section15); +bool emberAfIasAceClusterGetZoneIdMapResponseCallback(uint16_t section0, uint16_t section1, uint16_t section2, uint16_t section3, + uint16_t section4, uint16_t section5, uint16_t section6, uint16_t section7, + uint16_t section8, uint16_t section9, uint16_t section10, uint16_t section11, + uint16_t section12, uint16_t section13, uint16_t section14, + uint16_t section15); /** @brief IAS ACE Cluster Get Zone Information * - * + * * * @param zoneId Ver.: always */ bool emberAfIasAceClusterGetZoneInformationCallback(uint8_t zoneId); /** @brief IAS ACE Cluster Get Zone Information Response * - * + * * * @param zoneId Ver.: always * @param zoneType Ver.: always * @param ieeeAddress Ver.: always * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 */ -bool emberAfIasAceClusterGetZoneInformationResponseCallback(uint8_t zoneId, - uint16_t zoneType, - uint8_t* ieeeAddress, - uint8_t* zoneLabel); +bool emberAfIasAceClusterGetZoneInformationResponseCallback(uint8_t zoneId, uint16_t zoneType, uint8_t * ieeeAddress, + uint8_t * zoneLabel); /** @brief IAS ACE Cluster Get Zone Status * - * + * * * @param startingZoneId Ver.: always * @param maxNumberOfZoneIds Ver.: always * @param zoneStatusMaskFlag Ver.: always * @param zoneStatusMask Ver.: always */ -bool emberAfIasAceClusterGetZoneStatusCallback(uint8_t startingZoneId, - uint8_t maxNumberOfZoneIds, - uint8_t zoneStatusMaskFlag, - uint16_t zoneStatusMask); +bool emberAfIasAceClusterGetZoneStatusCallback(uint8_t startingZoneId, uint8_t maxNumberOfZoneIds, uint8_t zoneStatusMaskFlag, + uint16_t zoneStatusMask); /** @brief IAS ACE Cluster Get Zone Status Response * - * + * * * @param zoneStatusComplete Ver.: always * @param numberOfZones Ver.: always * @param zoneStatusResult Ver.: always */ -bool emberAfIasAceClusterGetZoneStatusResponseCallback(uint8_t zoneStatusComplete, - uint8_t numberOfZones, - uint8_t* zoneStatusResult); +bool emberAfIasAceClusterGetZoneStatusResponseCallback(uint8_t zoneStatusComplete, uint8_t numberOfZones, + uint8_t * zoneStatusResult); /** @brief IAS ACE Cluster Panel Status Changed * - * + * * * @param panelStatus Ver.: always * @param secondsRemaining Ver.: always * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 * @param alarmStatus Ver.: since ha-1.2.1-05-3520-30 */ -bool emberAfIasAceClusterPanelStatusChangedCallback(uint8_t panelStatus, - uint8_t secondsRemaining, - uint8_t audibleNotification, - uint8_t alarmStatus); +bool emberAfIasAceClusterPanelStatusChangedCallback(uint8_t panelStatus, uint8_t secondsRemaining, uint8_t audibleNotification, + uint8_t alarmStatus); /** @brief IAS ACE Cluster Panic * - * + * * */ bool emberAfIasAceClusterPanicCallback(void); @@ -16370,8 +14804,7 @@ bool emberAfIasAceClusterPanicCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasAceClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasAceClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS ACE Cluster Server Default Response * * This function is called when the server receives the default response from @@ -16381,9 +14814,7 @@ void emberAfIasAceClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasAceClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasAceClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS ACE Cluster Server Init * * Server Init @@ -16397,11 +14828,10 @@ void emberAfIasAceClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasAceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasAceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS ACE Cluster Server Message Sent * @@ -16415,11 +14845,8 @@ void emberAfIasAceClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasAceClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIasAceClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS ACE Cluster Server Pre Attribute Changed * @@ -16431,11 +14858,9 @@ void emberAfIasAceClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasAceClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasAceClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS ACE Cluster Server Tick * * Server Tick @@ -16445,26 +14870,23 @@ EmberAfStatus emberAfIasAceClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfIasAceClusterServerTickCallback(uint8_t endpoint); /** @brief IAS ACE Cluster Set Bypassed Zone List * - * + * * * @param numberOfZones Ver.: always * @param zoneIds Ver.: always */ -bool emberAfIasAceClusterSetBypassedZoneListCallback(uint8_t numberOfZones, - uint8_t* zoneIds); +bool emberAfIasAceClusterSetBypassedZoneListCallback(uint8_t numberOfZones, uint8_t * zoneIds); /** @brief IAS ACE Cluster Zone Status Changed * - * + * * * @param zoneId Ver.: always * @param zoneStatus Ver.: always * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 */ -bool emberAfIasAceClusterZoneStatusChangedCallback(uint8_t zoneId, - uint16_t zoneStatus, - uint8_t audibleNotification, - uint8_t* zoneLabel); +bool emberAfIasAceClusterZoneStatusChangedCallback(uint8_t zoneId, uint16_t zoneStatus, uint8_t audibleNotification, + uint8_t * zoneLabel); /** @} END IAS ACE Cluster Callbacks */ @@ -16478,8 +14900,7 @@ bool emberAfIasAceClusterZoneStatusChangedCallback(uint8_t zoneId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasWdClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasWdClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS WD Cluster Client Default Response * * This function is called when the client receives the default response from @@ -16489,9 +14910,7 @@ void emberAfIasWdClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasWdClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasWdClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS WD Cluster Client Init * * Client Init @@ -16505,11 +14924,10 @@ void emberAfIasWdClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasWdClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasWdClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS WD Cluster Client Message Sent * @@ -16523,12 +14941,8 @@ void emberAfIasWdClusterClientManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasWdClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfIasWdClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS WD Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -16539,11 +14953,9 @@ void emberAfIasWdClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasWdClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasWdClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS WD Cluster Client Tick * * Client Tick @@ -16558,8 +14970,7 @@ void emberAfIasWdClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIasWdClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIasWdClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief IAS WD Cluster Server Default Response * * This function is called when the server receives the default response from @@ -16569,9 +14980,7 @@ void emberAfIasWdClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIasWdClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIasWdClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief IAS WD Cluster Server Init * * Server Init @@ -16585,11 +14994,10 @@ void emberAfIasWdClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfIasWdClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfIasWdClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief IAS WD Cluster Server Message Sent * @@ -16603,12 +15011,8 @@ void emberAfIasWdClusterServerManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIasWdClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfIasWdClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief IAS WD Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -16619,11 +15023,9 @@ void emberAfIasWdClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIasWdClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIasWdClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief IAS WD Cluster Server Tick * * Server Tick @@ -16633,24 +15035,22 @@ EmberAfStatus emberAfIasWdClusterServerPreAttributeChangedCallback(uint8_t endpo void emberAfIasWdClusterServerTickCallback(uint8_t endpoint); /** @brief IAS WD Cluster Squawk * - * + * * * @param squawkInfo Ver.: always */ bool emberAfIasWdClusterSquawkCallback(uint8_t squawkInfo); /** @brief IAS WD Cluster Start Warning * - * + * * * @param warningInfo Ver.: always * @param warningDuration Ver.: always * @param strobeDutyCycle Ver.: since ha-1.2-05-3520-29 * @param strobeLevel Ver.: since ha-1.2-05-3520-29 */ -bool emberAfIasWdClusterStartWarningCallback(uint8_t warningInfo, - uint16_t warningDuration, - uint8_t strobeDutyCycle, - uint8_t strobeLevel); +bool emberAfIasWdClusterStartWarningCallback(uint8_t warningInfo, uint16_t warningDuration, uint8_t strobeDutyCycle, + uint8_t strobeLevel); /** @} END IAS WD Cluster Callbacks */ @@ -16659,11 +15059,11 @@ bool emberAfIasWdClusterStartWarningCallback(uint8_t warningInfo, /** @brief Generic Tunnel Cluster Advertise Protocol Address * - * + * * * @param protocolAddress Ver.: always */ -bool emberAfGenericTunnelClusterAdvertiseProtocolAddressCallback(uint8_t* protocolAddress); +bool emberAfGenericTunnelClusterAdvertiseProtocolAddressCallback(uint8_t * protocolAddress); /** @brief Generic Tunnel Cluster Client Attribute Changed * * Client Attribute Changed @@ -16671,8 +15071,7 @@ bool emberAfGenericTunnelClusterAdvertiseProtocolAddressCallback(uint8_t* protoc * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGenericTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGenericTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Generic Tunnel Cluster Client Default Response * * This function is called when the client receives the default response from @@ -16682,9 +15081,7 @@ void emberAfGenericTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGenericTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGenericTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Generic Tunnel Cluster Client Init * * Client Init @@ -16698,11 +15095,10 @@ void emberAfGenericTunnelClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGenericTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGenericTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Generic Tunnel Cluster Client Message Sent * @@ -16716,11 +15112,8 @@ void emberAfGenericTunnelClusterClientManufacturerSpecificAttributeChangedCallba * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGenericTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGenericTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Generic Tunnel Cluster Client Pre Attribute Changed * @@ -16732,11 +15125,9 @@ void emberAfGenericTunnelClusterClientMessageSentCallback(EmberOutgoingMessageTy * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGenericTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGenericTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Generic Tunnel Cluster Client Tick * * Client Tick @@ -16746,20 +15137,19 @@ EmberAfStatus emberAfGenericTunnelClusterClientPreAttributeChangedCallback(uint8 void emberAfGenericTunnelClusterClientTickCallback(uint8_t endpoint); /** @brief Generic Tunnel Cluster Match Protocol Address * - * + * * * @param protocolAddress Ver.: always */ -bool emberAfGenericTunnelClusterMatchProtocolAddressCallback(uint8_t* protocolAddress); +bool emberAfGenericTunnelClusterMatchProtocolAddressCallback(uint8_t * protocolAddress); /** @brief Generic Tunnel Cluster Match Protocol Address Response * - * + * * * @param deviceIeeeAddress Ver.: always * @param protocolAddress Ver.: always */ -bool emberAfGenericTunnelClusterMatchProtocolAddressResponseCallback(uint8_t* deviceIeeeAddress, - uint8_t* protocolAddress); +bool emberAfGenericTunnelClusterMatchProtocolAddressResponseCallback(uint8_t * deviceIeeeAddress, uint8_t * protocolAddress); /** @brief Generic Tunnel Cluster Server Attribute Changed * * Server Attribute Changed @@ -16767,8 +15157,7 @@ bool emberAfGenericTunnelClusterMatchProtocolAddressResponseCallback(uint8_t* de * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGenericTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGenericTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Generic Tunnel Cluster Server Default Response * * This function is called when the server receives the default response from @@ -16778,9 +15167,7 @@ void emberAfGenericTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGenericTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGenericTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Generic Tunnel Cluster Server Init * * Server Init @@ -16794,11 +15181,10 @@ void emberAfGenericTunnelClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGenericTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGenericTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Generic Tunnel Cluster Server Message Sent * @@ -16812,11 +15198,8 @@ void emberAfGenericTunnelClusterServerManufacturerSpecificAttributeChangedCallba * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGenericTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGenericTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Generic Tunnel Cluster Server Pre Attribute Changed * @@ -16828,11 +15211,9 @@ void emberAfGenericTunnelClusterServerMessageSentCallback(EmberOutgoingMessageTy * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGenericTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGenericTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Generic Tunnel Cluster Server Tick * * Server Tick @@ -16853,8 +15234,7 @@ void emberAfGenericTunnelClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBacnetProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBacnetProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief BACnet Protocol Tunnel Cluster Client Default Response * * This function is called when the client receives the default response from @@ -16864,9 +15244,7 @@ void emberAfBacnetProtocolTunnelClusterClientAttributeChangedCallback(uint8_t en * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBacnetProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBacnetProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief BACnet Protocol Tunnel Cluster Client Init * * Client Init @@ -16880,7 +15258,7 @@ void emberAfBacnetProtocolTunnelClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBacnetProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -16898,11 +15276,8 @@ void emberAfBacnetProtocolTunnelClusterClientManufacturerSpecificAttributeChange * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBacnetProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBacnetProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief BACnet Protocol Tunnel Cluster Client Pre Attribute Changed * @@ -16914,11 +15289,9 @@ void emberAfBacnetProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMe * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBacnetProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBacnetProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief BACnet Protocol Tunnel Cluster Client Tick * * Client Tick @@ -16933,8 +15306,7 @@ void emberAfBacnetProtocolTunnelClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBacnetProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBacnetProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief BACnet Protocol Tunnel Cluster Server Default Response * * This function is called when the server receives the default response from @@ -16944,9 +15316,7 @@ void emberAfBacnetProtocolTunnelClusterServerAttributeChangedCallback(uint8_t en * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBacnetProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBacnetProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief BACnet Protocol Tunnel Cluster Server Init * * Server Init @@ -16960,7 +15330,7 @@ void emberAfBacnetProtocolTunnelClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfBacnetProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -16978,11 +15348,8 @@ void emberAfBacnetProtocolTunnelClusterServerManufacturerSpecificAttributeChange * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBacnetProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBacnetProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief BACnet Protocol Tunnel Cluster Server Pre Attribute Changed * @@ -16994,11 +15361,9 @@ void emberAfBacnetProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMe * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBacnetProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBacnetProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief BACnet Protocol Tunnel Cluster Server Tick * * Server Tick @@ -17008,11 +15373,11 @@ EmberAfStatus emberAfBacnetProtocolTunnelClusterServerPreAttributeChangedCallbac void emberAfBacnetProtocolTunnelClusterServerTickCallback(uint8_t endpoint); /** @brief BACnet Protocol Tunnel Cluster Transfer Npdu * - * + * * * @param npdu Ver.: always */ -bool emberAfBacnetProtocolTunnelClusterTransferNpduCallback(uint8_t* npdu); +bool emberAfBacnetProtocolTunnelClusterTransferNpduCallback(uint8_t * npdu); /** @} END BACnet Protocol Tunnel Cluster Callbacks */ @@ -17026,8 +15391,7 @@ bool emberAfBacnetProtocolTunnelClusterTransferNpduCallback(uint8_t* npdu); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAf11073ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAf11073ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief 11073 Protocol Tunnel Cluster Client Default Response * * This function is called when the client receives the default response from @@ -17037,9 +15401,7 @@ void emberAf11073ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAf11073ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAf11073ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief 11073 Protocol Tunnel Cluster Client Init * * Client Init @@ -17053,7 +15415,7 @@ void emberAf11073ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAf11073ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -17071,11 +15433,8 @@ void emberAf11073ProtocolTunnelClusterClientManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAf11073ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAf11073ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief 11073 Protocol Tunnel Cluster Client Pre Attribute Changed * @@ -17087,11 +15446,9 @@ void emberAf11073ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAf11073ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAf11073ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief 11073 Protocol Tunnel Cluster Client Tick * * Client Tick @@ -17101,31 +15458,29 @@ EmberAfStatus emberAf11073ProtocolTunnelClusterClientPreAttributeChangedCallback void emberAf11073ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); /** @brief 11073 Protocol Tunnel Cluster Connect Request * - * + * * * @param connectControl Ver.: always * @param idleTimeout Ver.: always * @param managerTarget Ver.: always * @param managerEndpoint Ver.: always */ -bool emberAf11073ProtocolTunnelClusterConnectRequestCallback(uint8_t connectControl, - uint16_t idleTimeout, - uint8_t* managerTarget, - uint8_t managerEndpoint); +bool emberAf11073ProtocolTunnelClusterConnectRequestCallback(uint8_t connectControl, uint16_t idleTimeout, uint8_t * managerTarget, + uint8_t managerEndpoint); /** @brief 11073 Protocol Tunnel Cluster Connect Status Notification * - * + * * * @param connectStatus Ver.: always */ bool emberAf11073ProtocolTunnelClusterConnectStatusNotificationCallback(uint8_t connectStatus); /** @brief 11073 Protocol Tunnel Cluster Disconnect Request * - * + * * * @param managerIEEEAddress Ver.: always */ -bool emberAf11073ProtocolTunnelClusterDisconnectRequestCallback(uint8_t* managerIEEEAddress); +bool emberAf11073ProtocolTunnelClusterDisconnectRequestCallback(uint8_t * managerIEEEAddress); /** @brief 11073 Protocol Tunnel Cluster Server Attribute Changed * * Server Attribute Changed @@ -17133,8 +15488,7 @@ bool emberAf11073ProtocolTunnelClusterDisconnectRequestCallback(uint8_t* manager * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAf11073ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAf11073ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief 11073 Protocol Tunnel Cluster Server Default Response * * This function is called when the server receives the default response from @@ -17144,9 +15498,7 @@ void emberAf11073ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAf11073ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAf11073ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief 11073 Protocol Tunnel Cluster Server Init * * Server Init @@ -17160,7 +15512,7 @@ void emberAf11073ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAf11073ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -17178,11 +15530,8 @@ void emberAf11073ProtocolTunnelClusterServerManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAf11073ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAf11073ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief 11073 Protocol Tunnel Cluster Server Pre Attribute Changed * @@ -17194,11 +15543,9 @@ void emberAf11073ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAf11073ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAf11073ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief 11073 Protocol Tunnel Cluster Server Tick * * Server Tick @@ -17208,11 +15555,11 @@ EmberAfStatus emberAf11073ProtocolTunnelClusterServerPreAttributeChangedCallback void emberAf11073ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); /** @brief 11073 Protocol Tunnel Cluster Transfer A P D U * - * + * * * @param apdu Ver.: always */ -bool emberAf11073ProtocolTunnelClusterTransferAPDUCallback(uint8_t* apdu); +bool emberAf11073ProtocolTunnelClusterTransferAPDUCallback(uint8_t * apdu); /** @} END 11073 Protocol Tunnel Cluster Callbacks */ @@ -17226,8 +15573,7 @@ bool emberAf11073ProtocolTunnelClusterTransferAPDUCallback(uint8_t* apdu); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIso7816ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief ISO 7816 Protocol Tunnel Cluster Client Default Response * * This function is called when the client receives the default response from @@ -17237,9 +15583,7 @@ void emberAfIso7816ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t e * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIso7816ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief ISO 7816 Protocol Tunnel Cluster Client Init * * Client Init @@ -17253,7 +15597,7 @@ void emberAfIso7816ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIso7816ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -17271,11 +15615,8 @@ void emberAfIso7816ProtocolTunnelClusterClientManufacturerSpecificAttributeChang * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIso7816ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief ISO 7816 Protocol Tunnel Cluster Client Pre Attribute Changed * @@ -17287,11 +15628,9 @@ void emberAfIso7816ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingM * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIso7816ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIso7816ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief ISO 7816 Protocol Tunnel Cluster Client Tick * * Client Tick @@ -17301,13 +15640,13 @@ EmberAfStatus emberAfIso7816ProtocolTunnelClusterClientPreAttributeChangedCallba void emberAfIso7816ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); /** @brief ISO 7816 Protocol Tunnel Cluster Extract Smart Card * - * + * * */ bool emberAfIso7816ProtocolTunnelClusterExtractSmartCardCallback(void); /** @brief ISO 7816 Protocol Tunnel Cluster Insert Smart Card * - * + * * */ bool emberAfIso7816ProtocolTunnelClusterInsertSmartCardCallback(void); @@ -17318,8 +15657,7 @@ bool emberAfIso7816ProtocolTunnelClusterInsertSmartCardCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfIso7816ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief ISO 7816 Protocol Tunnel Cluster Server Default Response * * This function is called when the server receives the default response from @@ -17329,9 +15667,7 @@ void emberAfIso7816ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t e * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfIso7816ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief ISO 7816 Protocol Tunnel Cluster Server Init * * Server Init @@ -17345,7 +15681,7 @@ void emberAfIso7816ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfIso7816ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -17363,11 +15699,8 @@ void emberAfIso7816ProtocolTunnelClusterServerManufacturerSpecificAttributeChang * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfIso7816ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfIso7816ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief ISO 7816 Protocol Tunnel Cluster Server Pre Attribute Changed * @@ -17379,11 +15712,9 @@ void emberAfIso7816ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingM * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfIso7816ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfIso7816ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief ISO 7816 Protocol Tunnel Cluster Server Tick * * Server Tick @@ -17393,11 +15724,11 @@ EmberAfStatus emberAfIso7816ProtocolTunnelClusterServerPreAttributeChangedCallba void emberAfIso7816ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); /** @brief ISO 7816 Protocol Tunnel Cluster Transfer Apdu * - * + * * * @param apdu Ver.: always */ -bool emberAfIso7816ProtocolTunnelClusterTransferApduCallback(uint8_t* apdu); +bool emberAfIso7816ProtocolTunnelClusterTransferApduCallback(uint8_t * apdu); /** @} END ISO 7816 Protocol Tunnel Cluster Callbacks */ @@ -17406,15 +15737,13 @@ bool emberAfIso7816ProtocolTunnelClusterTransferApduCallback(uint8_t* apdu); /** @brief Price Cluster Cancel Tariff * - * + * * * @param providerId Ver.: always * @param issuerTariffId Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterCancelTariffCallback(uint32_t providerId, - uint32_t issuerTariffId, - uint8_t tariffType); +bool emberAfPriceClusterCancelTariffCallback(uint32_t providerId, uint32_t issuerTariffId, uint8_t tariffType); /** @brief Price Cluster Client Attribute Changed * * Client Attribute Changed @@ -17422,8 +15751,7 @@ bool emberAfPriceClusterCancelTariffCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPriceClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPriceClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Price Cluster Client Default Response * * This function is called when the client receives the default response from @@ -17433,9 +15761,7 @@ void emberAfPriceClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPriceClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPriceClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Price Cluster Client Init * * Client Init @@ -17449,11 +15775,10 @@ void emberAfPriceClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPriceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPriceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Price Cluster Client Message Sent * @@ -17467,12 +15792,8 @@ void emberAfPriceClusterClientManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPriceClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfPriceClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Price Cluster Client Pre Attribute Changed * * Client Pre Attribute Changed @@ -17483,11 +15804,9 @@ void emberAfPriceClusterClientMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPriceClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPriceClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Price Cluster Client Tick * * Client Tick @@ -17497,172 +15816,154 @@ EmberAfStatus emberAfPriceClusterClientPreAttributeChangedCallback(uint8_t endpo void emberAfPriceClusterClientTickCallback(uint8_t endpoint); /** @brief Price Cluster Cpp Event Response * - * + * * * @param issuerEventId Ver.: always * @param cppAuth Ver.: always */ -bool emberAfPriceClusterCppEventResponseCallback(uint32_t issuerEventId, - uint8_t cppAuth); +bool emberAfPriceClusterCppEventResponseCallback(uint32_t issuerEventId, uint8_t cppAuth); /** @brief Price Cluster Get Billing Period * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterGetBillingPeriodCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands, - uint8_t tariffType); +bool emberAfPriceClusterGetBillingPeriodCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); /** @brief Price Cluster Get Block Periods * - * + * * * @param startTime Ver.: always * @param numberOfEvents Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterGetBlockPeriodsCallback(uint32_t startTime, - uint8_t numberOfEvents, - uint8_t tariffType); +bool emberAfPriceClusterGetBlockPeriodsCallback(uint32_t startTime, uint8_t numberOfEvents, uint8_t tariffType); /** @brief Price Cluster Get Block Thresholds * - * + * * * @param issuerTariffId Ver.: always */ bool emberAfPriceClusterGetBlockThresholdsCallback(uint32_t issuerTariffId); /** @brief Price Cluster Get C O2 Value * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterGetCO2ValueCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands, - uint8_t tariffType); +bool emberAfPriceClusterGetCO2ValueCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); /** @brief Price Cluster Get Calorific Value * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always */ -bool emberAfPriceClusterGetCalorificValueCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands); +bool emberAfPriceClusterGetCalorificValueCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands); /** @brief Price Cluster Get Consolidated Bill * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterGetConsolidatedBillCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands, - uint8_t tariffType); +bool emberAfPriceClusterGetConsolidatedBillCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); /** @brief Price Cluster Get Conversion Factor * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always */ -bool emberAfPriceClusterGetConversionFactorCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands); +bool emberAfPriceClusterGetConversionFactorCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, + uint8_t numberOfCommands); /** @brief Price Cluster Get Credit Payment * - * + * * * @param latestEndTime Ver.: always * @param numberOfRecords Ver.: always */ -bool emberAfPriceClusterGetCreditPaymentCallback(uint32_t latestEndTime, - uint8_t numberOfRecords); +bool emberAfPriceClusterGetCreditPaymentCallback(uint32_t latestEndTime, uint8_t numberOfRecords); /** @brief Price Cluster Get Currency Conversion Command * - * + * * */ bool emberAfPriceClusterGetCurrencyConversionCommandCallback(void); /** @brief Price Cluster Get Current Price * - * + * * * @param commandOptions Ver.: always */ bool emberAfPriceClusterGetCurrentPriceCallback(uint8_t commandOptions); /** @brief Price Cluster Get Price Matrix * - * + * * * @param issuerTariffId Ver.: always */ bool emberAfPriceClusterGetPriceMatrixCallback(uint32_t issuerTariffId); /** @brief Price Cluster Get Scheduled Prices * - * + * * * @param startTime Ver.: always * @param numberOfEvents Ver.: always */ -bool emberAfPriceClusterGetScheduledPricesCallback(uint32_t startTime, - uint8_t numberOfEvents); +bool emberAfPriceClusterGetScheduledPricesCallback(uint32_t startTime, uint8_t numberOfEvents); /** @brief Price Cluster Get Tariff Cancellation * - * + * * */ bool emberAfPriceClusterGetTariffCancellationCallback(void); /** @brief Price Cluster Get Tariff Information * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always * @param numberOfCommands Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterGetTariffInformationCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCommands, - uint8_t tariffType); +bool emberAfPriceClusterGetTariffInformationCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, + uint8_t numberOfCommands, uint8_t tariffType); /** @brief Price Cluster Get Tier Labels * - * + * * * @param issuerTariffId Ver.: always */ bool emberAfPriceClusterGetTierLabelsCallback(uint32_t issuerTariffId); /** @brief Price Cluster Price Acknowledgement * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always * @param priceAckTime Ver.: always * @param control Ver.: always */ -bool emberAfPriceClusterPriceAcknowledgementCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t priceAckTime, - uint8_t control); +bool emberAfPriceClusterPriceAcknowledgementCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t priceAckTime, + uint8_t control); /** @brief Price Cluster Publish Billing Period * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17671,15 +15972,12 @@ bool emberAfPriceClusterPriceAcknowledgementCallback(uint32_t providerId, * @param billingPeriodDurationType Ver.: always * @param tariffType Ver.: always */ -bool emberAfPriceClusterPublishBillingPeriodCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t billingPeriodStartTime, - uint32_t billingPeriodDuration, - uint8_t billingPeriodDurationType, - uint8_t tariffType); +bool emberAfPriceClusterPublishBillingPeriodCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t billingPeriodStartTime, + uint32_t billingPeriodDuration, uint8_t billingPeriodDurationType, + uint8_t tariffType); /** @brief Price Cluster Publish Block Period * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17690,17 +15988,13 @@ bool emberAfPriceClusterPublishBillingPeriodCallback(uint32_t providerId, * @param tariffType Ver.: since se-1.2a-07-5356-19 * @param tariffResolutionPeriod Ver.: since se-1.2a-07-5356-19 */ -bool emberAfPriceClusterPublishBlockPeriodCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t blockPeriodStartTime, - uint32_t blockPeriodDuration, - uint8_t blockPeriodControl, - uint8_t blockPeriodDurationType, - uint8_t tariffType, - uint8_t tariffResolutionPeriod); +bool emberAfPriceClusterPublishBlockPeriodCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t blockPeriodStartTime, + uint32_t blockPeriodDuration, uint8_t blockPeriodControl, + uint8_t blockPeriodDurationType, uint8_t tariffType, + uint8_t tariffResolutionPeriod); /** @brief Price Cluster Publish Block Thresholds * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17711,17 +16005,12 @@ bool emberAfPriceClusterPublishBlockPeriodCallback(uint32_t providerId, * @param subPayloadControl Ver.: always * @param payload Ver.: always */ -bool emberAfPriceClusterPublishBlockThresholdsCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t startTime, - uint32_t issuerTariffId, - uint8_t commandIndex, - uint8_t numberOfCommands, - uint8_t subPayloadControl, - uint8_t* payload); +bool emberAfPriceClusterPublishBlockThresholdsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint32_t issuerTariffId, uint8_t commandIndex, uint8_t numberOfCommands, + uint8_t subPayloadControl, uint8_t * payload); /** @brief Price Cluster Publish C O2 Value * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17731,16 +16020,11 @@ bool emberAfPriceClusterPublishBlockThresholdsCallback(uint32_t providerId, * @param cO2ValueUnit Ver.: always * @param cO2ValueTrailingDigit Ver.: always */ -bool emberAfPriceClusterPublishCO2ValueCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t startTime, - uint8_t tariffType, - uint32_t cO2Value, - uint8_t cO2ValueUnit, - uint8_t cO2ValueTrailingDigit); +bool emberAfPriceClusterPublishCO2ValueCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, uint8_t tariffType, + uint32_t cO2Value, uint8_t cO2ValueUnit, uint8_t cO2ValueTrailingDigit); /** @brief Price Cluster Publish Calorific Value * - * + * * * @param issuerEventId Ver.: always * @param startTime Ver.: always @@ -17748,14 +16032,11 @@ bool emberAfPriceClusterPublishCO2ValueCallback(uint32_t providerId, * @param calorificValueUnit Ver.: always * @param calorificValueTrailingDigit Ver.: always */ -bool emberAfPriceClusterPublishCalorificValueCallback(uint32_t issuerEventId, - uint32_t startTime, - uint32_t calorificValue, - uint8_t calorificValueUnit, - uint8_t calorificValueTrailingDigit); +bool emberAfPriceClusterPublishCalorificValueCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t calorificValue, + uint8_t calorificValueUnit, uint8_t calorificValueTrailingDigit); /** @brief Price Cluster Publish Consolidated Bill * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17767,31 +16048,24 @@ bool emberAfPriceClusterPublishCalorificValueCallback(uint32_t issuerEventId, * @param currency Ver.: always * @param billTrailingDigit Ver.: always */ -bool emberAfPriceClusterPublishConsolidatedBillCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t billingPeriodStartTime, - uint32_t billingPeriodDuration, - uint8_t billingPeriodDurationType, - uint8_t tariffType, - uint32_t consolidatedBill, - uint16_t currency, - uint8_t billTrailingDigit); +bool emberAfPriceClusterPublishConsolidatedBillCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t billingPeriodStartTime, uint32_t billingPeriodDuration, + uint8_t billingPeriodDurationType, uint8_t tariffType, + uint32_t consolidatedBill, uint16_t currency, uint8_t billTrailingDigit); /** @brief Price Cluster Publish Conversion Factor * - * + * * * @param issuerEventId Ver.: always * @param startTime Ver.: always * @param conversionFactor Ver.: always * @param conversionFactorTrailingDigit Ver.: always */ -bool emberAfPriceClusterPublishConversionFactorCallback(uint32_t issuerEventId, - uint32_t startTime, - uint32_t conversionFactor, - uint8_t conversionFactorTrailingDigit); +bool emberAfPriceClusterPublishConversionFactorCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit); /** @brief Price Cluster Publish Cpp Event * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17801,16 +16075,12 @@ bool emberAfPriceClusterPublishConversionFactorCallback(uint32_t issuerEventId, * @param cppPriceTier Ver.: always * @param cppAuth Ver.: always */ -bool emberAfPriceClusterPublishCppEventCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t startTime, - uint16_t durationInMinutes, - uint8_t tariffType, - uint8_t cppPriceTier, - uint8_t cppAuth); +bool emberAfPriceClusterPublishCppEventCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint16_t durationInMinutes, uint8_t tariffType, uint8_t cppPriceTier, + uint8_t cppAuth); /** @brief Price Cluster Publish Credit Payment * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17821,17 +16091,13 @@ bool emberAfPriceClusterPublishCppEventCallback(uint32_t providerId, * @param creditPaymentDate Ver.: always * @param creditPaymentRef Ver.: always */ -bool emberAfPriceClusterPublishCreditPaymentCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t creditPaymentDueDate, - uint32_t creditPaymentOverDueAmount, - uint8_t creditPaymentStatus, - uint32_t creditPayment, - uint32_t creditPaymentDate, - uint8_t* creditPaymentRef); +bool emberAfPriceClusterPublishCreditPaymentCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t creditPaymentDueDate, + uint32_t creditPaymentOverDueAmount, uint8_t creditPaymentStatus, + uint32_t creditPayment, uint32_t creditPaymentDate, + uint8_t * creditPaymentRef); /** @brief Price Cluster Publish Currency Conversion * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17842,17 +16108,13 @@ bool emberAfPriceClusterPublishCreditPaymentCallback(uint32_t providerId, * @param conversionFactorTrailingDigit Ver.: always * @param currencyChangeControlFlags Ver.: always */ -bool emberAfPriceClusterPublishCurrencyConversionCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t startTime, - uint16_t oldCurrency, - uint16_t newCurrency, - uint32_t conversionFactor, - uint8_t conversionFactorTrailingDigit, - uint32_t currencyChangeControlFlags); +bool emberAfPriceClusterPublishCurrencyConversionCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint16_t oldCurrency, uint16_t newCurrency, uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit, + uint32_t currencyChangeControlFlags); /** @brief Price Cluster Publish Price * - * + * * * @param providerId Ver.: always * @param rateLabel Ver.: always @@ -17879,33 +16141,16 @@ bool emberAfPriceClusterPublishCurrencyConversionCallback(uint32_t providerId, * @param extendedPriceTier Ver.: since se-1.2a-07-5356-19 * @param extendedRegisterTier Ver.: since se-1.2a-07-5356-19 */ -bool emberAfPriceClusterPublishPriceCallback(uint32_t providerId, - uint8_t* rateLabel, - uint32_t issuerEventId, - uint32_t currentTime, - uint8_t unitOfMeasure, - uint16_t currency, - uint8_t priceTrailingDigitAndPriceTier, - uint8_t numberOfPriceTiersAndRegisterTier, - uint32_t startTime, - uint16_t durationInMinutes, - uint32_t price, - uint8_t priceRatio, - uint32_t generationPrice, - uint8_t generationPriceRatio, - uint32_t alternateCostDelivered, - uint8_t alternateCostUnit, - uint8_t alternateCostTrailingDigit, - uint8_t numberOfBlockThresholds, - uint8_t priceControl, - uint8_t numberOfGenerationTiers, - uint8_t generationTier, - uint8_t extendedNumberOfPriceTiers, - uint8_t extendedPriceTier, - uint8_t extendedRegisterTier); +bool emberAfPriceClusterPublishPriceCallback( + uint32_t providerId, uint8_t * rateLabel, uint32_t issuerEventId, uint32_t currentTime, uint8_t unitOfMeasure, + uint16_t currency, uint8_t priceTrailingDigitAndPriceTier, uint8_t numberOfPriceTiersAndRegisterTier, uint32_t startTime, + uint16_t durationInMinutes, uint32_t price, uint8_t priceRatio, uint32_t generationPrice, uint8_t generationPriceRatio, + uint32_t alternateCostDelivered, uint8_t alternateCostUnit, uint8_t alternateCostTrailingDigit, uint8_t numberOfBlockThresholds, + uint8_t priceControl, uint8_t numberOfGenerationTiers, uint8_t generationTier, uint8_t extendedNumberOfPriceTiers, + uint8_t extendedPriceTier, uint8_t extendedRegisterTier); /** @brief Price Cluster Publish Price Matrix * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17916,17 +16161,12 @@ bool emberAfPriceClusterPublishPriceCallback(uint32_t providerId, * @param subPayloadControl Ver.: always * @param payload Ver.: always */ -bool emberAfPriceClusterPublishPriceMatrixCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t startTime, - uint32_t issuerTariffId, - uint8_t commandIndex, - uint8_t numberOfCommands, - uint8_t subPayloadControl, - uint8_t* payload); +bool emberAfPriceClusterPublishPriceMatrixCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint32_t issuerTariffId, uint8_t commandIndex, uint8_t numberOfCommands, + uint8_t subPayloadControl, uint8_t * payload); /** @brief Price Cluster Publish Tariff Information * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17944,24 +16184,16 @@ bool emberAfPriceClusterPublishPriceMatrixCallback(uint32_t providerId, * @param blockThresholdMultiplier Ver.: always * @param blockThresholdDivisor Ver.: always */ -bool emberAfPriceClusterPublishTariffInformationCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerTariffId, - uint32_t startTime, - uint8_t tariffTypeChargingScheme, - uint8_t* tariffLabel, - uint8_t numberOfPriceTiersInUse, - uint8_t numberOfBlockThresholdsInUse, - uint8_t unitOfMeasure, - uint16_t currency, - uint8_t priceTrailingDigit, - uint32_t standingCharge, - uint8_t tierBlockMode, - uint32_t blockThresholdMultiplier, - uint32_t blockThresholdDivisor); +bool emberAfPriceClusterPublishTariffInformationCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerTariffId, + uint32_t startTime, uint8_t tariffTypeChargingScheme, + uint8_t * tariffLabel, uint8_t numberOfPriceTiersInUse, + uint8_t numberOfBlockThresholdsInUse, uint8_t unitOfMeasure, + uint16_t currency, uint8_t priceTrailingDigit, uint32_t standingCharge, + uint8_t tierBlockMode, uint32_t blockThresholdMultiplier, + uint32_t blockThresholdDivisor); /** @brief Price Cluster Publish Tier Labels * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -17971,13 +16203,9 @@ bool emberAfPriceClusterPublishTariffInformationCallback(uint32_t providerId, * @param numberOfLabels Ver.: always * @param tierLabelsPayload Ver.: always */ -bool emberAfPriceClusterPublishTierLabelsCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerTariffId, - uint8_t commandIndex, - uint8_t numberOfCommands, - uint8_t numberOfLabels, - uint8_t* tierLabelsPayload); +bool emberAfPriceClusterPublishTierLabelsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerTariffId, + uint8_t commandIndex, uint8_t numberOfCommands, uint8_t numberOfLabels, + uint8_t * tierLabelsPayload); /** @brief Price Cluster Server Attribute Changed * * Server Attribute Changed @@ -17985,8 +16213,7 @@ bool emberAfPriceClusterPublishTierLabelsCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPriceClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPriceClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Price Cluster Server Default Response * * This function is called when the server receives the default response from @@ -17996,9 +16223,7 @@ void emberAfPriceClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPriceClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPriceClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Price Cluster Server Init * * Server Init @@ -18012,11 +16237,10 @@ void emberAfPriceClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPriceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPriceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Price Cluster Server Message Sent * @@ -18030,12 +16254,8 @@ void emberAfPriceClusterServerManufacturerSpecificAttributeChangedCallback(uint8 * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPriceClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, - EmberStatus status); +void emberAfPriceClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Price Cluster Server Pre Attribute Changed * * Server Pre Attribute Changed @@ -18046,11 +16266,9 @@ void emberAfPriceClusterServerMessageSentCallback(EmberOutgoingMessageType type, * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPriceClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPriceClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Price Cluster Server Tick * * Server Tick @@ -18066,14 +16284,14 @@ void emberAfPriceClusterServerTickCallback(uint8_t endpoint); /** @brief Demand Response and Load Control Cluster Cancel All Load Control Events * - * + * * * @param cancelControl Ver.: always */ bool emberAfDemandResponseLoadControlClusterCancelAllLoadControlEventsCallback(uint8_t cancelControl); /** @brief Demand Response and Load Control Cluster Cancel Load Control Event * - * + * * * @param issuerEventId Ver.: always * @param deviceClass Ver.: always @@ -18081,11 +16299,9 @@ bool emberAfDemandResponseLoadControlClusterCancelAllLoadControlEventsCallback(u * @param cancelControl Ver.: always * @param effectiveTime Ver.: always */ -bool emberAfDemandResponseLoadControlClusterCancelLoadControlEventCallback(uint32_t issuerEventId, - uint16_t deviceClass, - uint8_t utilityEnrollmentGroup, - uint8_t cancelControl, - uint32_t effectiveTime); +bool emberAfDemandResponseLoadControlClusterCancelLoadControlEventCallback(uint32_t issuerEventId, uint16_t deviceClass, + uint8_t utilityEnrollmentGroup, uint8_t cancelControl, + uint32_t effectiveTime); /** @brief Demand Response and Load Control Cluster Client Attribute Changed * * Client Attribute Changed @@ -18093,8 +16309,7 @@ bool emberAfDemandResponseLoadControlClusterCancelLoadControlEventCallback(uint3 * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDemandResponseLoadControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDemandResponseLoadControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Demand Response and Load Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -18104,8 +16319,7 @@ void emberAfDemandResponseLoadControlClusterClientAttributeChangedCallback(uint8 * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDemandResponseLoadControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfDemandResponseLoadControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Demand Response and Load Control Cluster Client Init * @@ -18120,7 +16334,7 @@ void emberAfDemandResponseLoadControlClusterClientInitCallback(uint8_t endpoint) * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDemandResponseLoadControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -18138,11 +16352,8 @@ void emberAfDemandResponseLoadControlClusterClientManufacturerSpecificAttributeC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDemandResponseLoadControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDemandResponseLoadControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Demand Response and Load Control Cluster Client Pre Attribute Changed * @@ -18157,8 +16368,7 @@ void emberAfDemandResponseLoadControlClusterClientMessageSentCallback(EmberOutgo EmberAfStatus emberAfDemandResponseLoadControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Demand Response and Load Control Cluster Client Tick * * Client Tick @@ -18168,18 +16378,17 @@ EmberAfStatus emberAfDemandResponseLoadControlClusterClientPreAttributeChangedCa void emberAfDemandResponseLoadControlClusterClientTickCallback(uint8_t endpoint); /** @brief Demand Response and Load Control Cluster Get Scheduled Events * - * + * * * @param startTime Ver.: always * @param numberOfEvents Ver.: always * @param issuerEventId Ver.: since se-1.2b-15-0131-02 */ -bool emberAfDemandResponseLoadControlClusterGetScheduledEventsCallback(uint32_t startTime, - uint8_t numberOfEvents, - uint32_t issuerEventId); +bool emberAfDemandResponseLoadControlClusterGetScheduledEventsCallback(uint32_t startTime, uint8_t numberOfEvents, + uint32_t issuerEventId); /** @brief Demand Response and Load Control Cluster Load Control Event * - * + * * * @param issuerEventId Ver.: always * @param deviceClass Ver.: always @@ -18195,22 +16404,14 @@ bool emberAfDemandResponseLoadControlClusterGetScheduledEventsCallback(uint32_t * @param dutyCycle Ver.: always * @param eventControl Ver.: always */ -bool emberAfDemandResponseLoadControlClusterLoadControlEventCallback(uint32_t issuerEventId, - uint16_t deviceClass, - uint8_t utilityEnrollmentGroup, - uint32_t startTime, - uint16_t durationInMinutes, - uint8_t criticalityLevel, - uint8_t coolingTemperatureOffset, - uint8_t heatingTemperatureOffset, - int16_t coolingTemperatureSetPoint, - int16_t heatingTemperatureSetPoint, - int8_t averageLoadAdjustmentPercentage, - uint8_t dutyCycle, - uint8_t eventControl); +bool emberAfDemandResponseLoadControlClusterLoadControlEventCallback( + uint32_t issuerEventId, uint16_t deviceClass, uint8_t utilityEnrollmentGroup, uint32_t startTime, uint16_t durationInMinutes, + uint8_t criticalityLevel, uint8_t coolingTemperatureOffset, uint8_t heatingTemperatureOffset, + int16_t coolingTemperatureSetPoint, int16_t heatingTemperatureSetPoint, int8_t averageLoadAdjustmentPercentage, + uint8_t dutyCycle, uint8_t eventControl); /** @brief Demand Response and Load Control Cluster Report Event Status * - * + * * * @param issuerEventId Ver.: always * @param eventStatus Ver.: always @@ -18224,17 +16425,13 @@ bool emberAfDemandResponseLoadControlClusterLoadControlEventCallback(uint32_t is * @param signatureType Ver.: always * @param signature Ver.: always */ -bool emberAfDemandResponseLoadControlClusterReportEventStatusCallback(uint32_t issuerEventId, - uint8_t eventStatus, - uint32_t eventStatusTime, - uint8_t criticalityLevelApplied, - uint16_t coolingTemperatureSetPointApplied, - uint16_t heatingTemperatureSetPointApplied, - int8_t averageLoadAdjustmentPercentageApplied, - uint8_t dutyCycleApplied, - uint8_t eventControl, - uint8_t signatureType, - uint8_t* signature); +bool emberAfDemandResponseLoadControlClusterReportEventStatusCallback(uint32_t issuerEventId, uint8_t eventStatus, + uint32_t eventStatusTime, uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, uint8_t eventControl, + uint8_t signatureType, uint8_t * signature); /** @brief Demand Response and Load Control Cluster Server Attribute Changed * * Server Attribute Changed @@ -18242,8 +16439,7 @@ bool emberAfDemandResponseLoadControlClusterReportEventStatusCallback(uint32_t i * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDemandResponseLoadControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDemandResponseLoadControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Demand Response and Load Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -18253,8 +16449,7 @@ void emberAfDemandResponseLoadControlClusterServerAttributeChangedCallback(uint8 * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDemandResponseLoadControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, +void emberAfDemandResponseLoadControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Demand Response and Load Control Cluster Server Init * @@ -18269,7 +16464,7 @@ void emberAfDemandResponseLoadControlClusterServerInitCallback(uint8_t endpoint) * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDemandResponseLoadControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -18287,11 +16482,8 @@ void emberAfDemandResponseLoadControlClusterServerManufacturerSpecificAttributeC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDemandResponseLoadControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDemandResponseLoadControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Demand Response and Load Control Cluster Server Pre Attribute Changed * @@ -18306,8 +16498,7 @@ void emberAfDemandResponseLoadControlClusterServerMessageSentCallback(EmberOutgo EmberAfStatus emberAfDemandResponseLoadControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Demand Response and Load Control Cluster Server Tick * * Server Tick @@ -18323,7 +16514,7 @@ void emberAfDemandResponseLoadControlClusterServerTickCallback(uint8_t endpoint) /** @brief Simple Metering Cluster Change Supply * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -18332,12 +16523,9 @@ void emberAfDemandResponseLoadControlClusterServerTickCallback(uint8_t endpoint) * @param proposedSupplyStatus Ver.: always * @param supplyControlBits Ver.: always */ -bool emberAfSimpleMeteringClusterChangeSupplyCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t requestDateTime, - uint32_t implementationDateTime, - uint8_t proposedSupplyStatus, - uint8_t supplyControlBits); +bool emberAfSimpleMeteringClusterChangeSupplyCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t requestDateTime, + uint32_t implementationDateTime, uint8_t proposedSupplyStatus, + uint8_t supplyControlBits); /** @brief Simple Metering Cluster Client Attribute Changed * * Client Attribute Changed @@ -18345,8 +16533,7 @@ bool emberAfSimpleMeteringClusterChangeSupplyCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSimpleMeteringClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSimpleMeteringClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Simple Metering Cluster Client Default Response * * This function is called when the client receives the default response from @@ -18356,9 +16543,7 @@ void emberAfSimpleMeteringClusterClientAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSimpleMeteringClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSimpleMeteringClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Simple Metering Cluster Client Init * * Client Init @@ -18372,7 +16557,7 @@ void emberAfSimpleMeteringClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSimpleMeteringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -18390,11 +16575,8 @@ void emberAfSimpleMeteringClusterClientManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSimpleMeteringClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSimpleMeteringClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Simple Metering Cluster Client Pre Attribute Changed * @@ -18406,11 +16588,9 @@ void emberAfSimpleMeteringClusterClientMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSimpleMeteringClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSimpleMeteringClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Simple Metering Cluster Client Tick * * Client Tick @@ -18420,20 +16600,18 @@ EmberAfStatus emberAfSimpleMeteringClusterClientPreAttributeChangedCallback(uint void emberAfSimpleMeteringClusterClientTickCallback(uint8_t endpoint); /** @brief Simple Metering Cluster Configure Mirror * - * + * * * @param issuerEventId Ver.: always * @param reportingInterval Ver.: always * @param mirrorNotificationReporting Ver.: always * @param notificationScheme Ver.: always */ -bool emberAfSimpleMeteringClusterConfigureMirrorCallback(uint32_t issuerEventId, - uint32_t reportingInterval, - uint8_t mirrorNotificationReporting, - uint8_t notificationScheme); +bool emberAfSimpleMeteringClusterConfigureMirrorCallback(uint32_t issuerEventId, uint32_t reportingInterval, + uint8_t mirrorNotificationReporting, uint8_t notificationScheme); /** @brief Simple Metering Cluster Configure Notification Flags * - * + * * * @param issuerEventId Ver.: always * @param notificationScheme Ver.: always @@ -18443,49 +16621,42 @@ bool emberAfSimpleMeteringClusterConfigureMirrorCallback(uint32_t issuerEventId, * @param numberOfCommands Ver.: always * @param commandIds Ver.: always */ -bool emberAfSimpleMeteringClusterConfigureNotificationFlagsCallback(uint32_t issuerEventId, - uint8_t notificationScheme, - uint16_t notificationFlagAttributeId, - uint16_t clusterId, - uint16_t manufacturerCode, - uint8_t numberOfCommands, - uint8_t* commandIds); +bool emberAfSimpleMeteringClusterConfigureNotificationFlagsCallback(uint32_t issuerEventId, uint8_t notificationScheme, + uint16_t notificationFlagAttributeId, uint16_t clusterId, + uint16_t manufacturerCode, uint8_t numberOfCommands, + uint8_t * commandIds); /** @brief Simple Metering Cluster Configure Notification Scheme * - * + * * * @param issuerEventId Ver.: always * @param notificationScheme Ver.: always * @param notificationFlagOrder Ver.: always */ -bool emberAfSimpleMeteringClusterConfigureNotificationSchemeCallback(uint32_t issuerEventId, - uint8_t notificationScheme, - uint32_t notificationFlagOrder); +bool emberAfSimpleMeteringClusterConfigureNotificationSchemeCallback(uint32_t issuerEventId, uint8_t notificationScheme, + uint32_t notificationFlagOrder); /** @brief Simple Metering Cluster Get Notified Message * - * + * * * @param notificationScheme Ver.: always * @param notificationFlagAttributeId Ver.: always * @param notificationFlagsN Ver.: always */ -bool emberAfSimpleMeteringClusterGetNotifiedMessageCallback(uint8_t notificationScheme, - uint16_t notificationFlagAttributeId, - uint32_t notificationFlagsN); +bool emberAfSimpleMeteringClusterGetNotifiedMessageCallback(uint8_t notificationScheme, uint16_t notificationFlagAttributeId, + uint32_t notificationFlagsN); /** @brief Simple Metering Cluster Get Profile * - * + * * * @param intervalChannel Ver.: always * @param endTime Ver.: always * @param numberOfPeriods Ver.: always */ -bool emberAfSimpleMeteringClusterGetProfileCallback(uint8_t intervalChannel, - uint32_t endTime, - uint8_t numberOfPeriods); +bool emberAfSimpleMeteringClusterGetProfileCallback(uint8_t intervalChannel, uint32_t endTime, uint8_t numberOfPeriods); /** @brief Simple Metering Cluster Get Profile Response * - * + * * * @param endTime Ver.: always * @param status Ver.: always @@ -18493,27 +16664,22 @@ bool emberAfSimpleMeteringClusterGetProfileCallback(uint8_t intervalChannel, * @param numberOfPeriodsDelivered Ver.: always * @param intervals Ver.: always */ -bool emberAfSimpleMeteringClusterGetProfileResponseCallback(uint32_t endTime, - uint8_t status, - uint8_t profileIntervalPeriod, - uint8_t numberOfPeriodsDelivered, - uint8_t* intervals); +bool emberAfSimpleMeteringClusterGetProfileResponseCallback(uint32_t endTime, uint8_t status, uint8_t profileIntervalPeriod, + uint8_t numberOfPeriodsDelivered, uint8_t * intervals); /** @brief Simple Metering Cluster Get Sampled Data * - * + * * * @param sampleId Ver.: always * @param earliestSampleTime Ver.: always * @param sampleType Ver.: always * @param numberOfSamples Ver.: always */ -bool emberAfSimpleMeteringClusterGetSampledDataCallback(uint16_t sampleId, - uint32_t earliestSampleTime, - uint8_t sampleType, - uint16_t numberOfSamples); +bool emberAfSimpleMeteringClusterGetSampledDataCallback(uint16_t sampleId, uint32_t earliestSampleTime, uint8_t sampleType, + uint16_t numberOfSamples); /** @brief Simple Metering Cluster Get Sampled Data Response * - * + * * * @param sampleId Ver.: always * @param sampleStartTime Ver.: always @@ -18522,51 +16688,45 @@ bool emberAfSimpleMeteringClusterGetSampledDataCallback(uint16_t sampleId, * @param numberOfSamples Ver.: always * @param samples Ver.: always */ -bool emberAfSimpleMeteringClusterGetSampledDataResponseCallback(uint16_t sampleId, - uint32_t sampleStartTime, - uint8_t sampleType, - uint16_t sampleRequestInterval, - uint16_t numberOfSamples, - uint8_t* samples); +bool emberAfSimpleMeteringClusterGetSampledDataResponseCallback(uint16_t sampleId, uint32_t sampleStartTime, uint8_t sampleType, + uint16_t sampleRequestInterval, uint16_t numberOfSamples, + uint8_t * samples); /** @brief Simple Metering Cluster Get Snapshot * - * + * * * @param earliestStartTime Ver.: always * @param latestEndTime Ver.: always * @param snapshotOffset Ver.: always * @param snapshotCause Ver.: always */ -bool emberAfSimpleMeteringClusterGetSnapshotCallback(uint32_t earliestStartTime, - uint32_t latestEndTime, - uint8_t snapshotOffset, - uint32_t snapshotCause); +bool emberAfSimpleMeteringClusterGetSnapshotCallback(uint32_t earliestStartTime, uint32_t latestEndTime, uint8_t snapshotOffset, + uint32_t snapshotCause); /** @brief Simple Metering Cluster Local Change Supply * - * + * * * @param proposedSupplyStatus Ver.: always */ bool emberAfSimpleMeteringClusterLocalChangeSupplyCallback(uint8_t proposedSupplyStatus); /** @brief Simple Metering Cluster Mirror Removed * - * + * * * @param endpointId Ver.: always */ bool emberAfSimpleMeteringClusterMirrorRemovedCallback(uint16_t endpointId); /** @brief Simple Metering Cluster Mirror Report Attribute Response * - * + * * * @param notificationScheme Ver.: always * @param notificationFlags Ver.: always */ -bool emberAfSimpleMeteringClusterMirrorReportAttributeResponseCallback(uint8_t notificationScheme, - uint8_t* notificationFlags); +bool emberAfSimpleMeteringClusterMirrorReportAttributeResponseCallback(uint8_t notificationScheme, uint8_t * notificationFlags); /** @brief Simple Metering Cluster Publish Snapshot * - * + * * * @param snapshotId Ver.: always * @param snapshotTime Ver.: always @@ -18577,82 +16737,71 @@ bool emberAfSimpleMeteringClusterMirrorReportAttributeResponseCallback(uint8_t n * @param snapshotPayloadType Ver.: always * @param snapshotPayload Ver.: always */ -bool emberAfSimpleMeteringClusterPublishSnapshotCallback(uint32_t snapshotId, - uint32_t snapshotTime, - uint8_t totalSnapshotsFound, - uint8_t commandIndex, - uint8_t totalCommands, - uint32_t snapshotCause, - uint8_t snapshotPayloadType, - uint8_t* snapshotPayload); +bool emberAfSimpleMeteringClusterPublishSnapshotCallback(uint32_t snapshotId, uint32_t snapshotTime, uint8_t totalSnapshotsFound, + uint8_t commandIndex, uint8_t totalCommands, uint32_t snapshotCause, + uint8_t snapshotPayloadType, uint8_t * snapshotPayload); /** @brief Simple Metering Cluster Remove Mirror * - * + * * */ bool emberAfSimpleMeteringClusterRemoveMirrorCallback(void); /** @brief Simple Metering Cluster Request Fast Poll Mode * - * + * * * @param fastPollUpdatePeriod Ver.: always * @param duration Ver.: always */ -bool emberAfSimpleMeteringClusterRequestFastPollModeCallback(uint8_t fastPollUpdatePeriod, - uint8_t duration); +bool emberAfSimpleMeteringClusterRequestFastPollModeCallback(uint8_t fastPollUpdatePeriod, uint8_t duration); /** @brief Simple Metering Cluster Request Fast Poll Mode Response * - * + * * * @param appliedUpdatePeriod Ver.: always * @param fastPollModeEndtime Ver.: always */ -bool emberAfSimpleMeteringClusterRequestFastPollModeResponseCallback(uint8_t appliedUpdatePeriod, - uint32_t fastPollModeEndtime); +bool emberAfSimpleMeteringClusterRequestFastPollModeResponseCallback(uint8_t appliedUpdatePeriod, uint32_t fastPollModeEndtime); /** @brief Simple Metering Cluster Request Mirror * - * + * * */ bool emberAfSimpleMeteringClusterRequestMirrorCallback(void); /** @brief Simple Metering Cluster Request Mirror Response * - * + * * * @param endpointId Ver.: always */ bool emberAfSimpleMeteringClusterRequestMirrorResponseCallback(uint16_t endpointId); /** @brief Simple Metering Cluster Reset Load Limit Counter * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always */ -bool emberAfSimpleMeteringClusterResetLoadLimitCounterCallback(uint32_t providerId, - uint32_t issuerEventId); +bool emberAfSimpleMeteringClusterResetLoadLimitCounterCallback(uint32_t providerId, uint32_t issuerEventId); /** @brief Simple Metering Cluster Schedule Snapshot * - * + * * * @param issuerEventId Ver.: always * @param commandIndex Ver.: always * @param commandCount Ver.: always * @param snapshotSchedulePayload Ver.: always */ -bool emberAfSimpleMeteringClusterScheduleSnapshotCallback(uint32_t issuerEventId, - uint8_t commandIndex, - uint8_t commandCount, - uint8_t* snapshotSchedulePayload); +bool emberAfSimpleMeteringClusterScheduleSnapshotCallback(uint32_t issuerEventId, uint8_t commandIndex, uint8_t commandCount, + uint8_t * snapshotSchedulePayload); /** @brief Simple Metering Cluster Schedule Snapshot Response * - * + * * * @param issuerEventId Ver.: always * @param snapshotResponsePayload Ver.: always */ -bool emberAfSimpleMeteringClusterScheduleSnapshotResponseCallback(uint32_t issuerEventId, - uint8_t* snapshotResponsePayload); +bool emberAfSimpleMeteringClusterScheduleSnapshotResponseCallback(uint32_t issuerEventId, uint8_t * snapshotResponsePayload); /** @brief Simple Metering Cluster Server Attribute Changed * * Server Attribute Changed @@ -18660,8 +16809,7 @@ bool emberAfSimpleMeteringClusterScheduleSnapshotResponseCallback(uint32_t issue * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSimpleMeteringClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSimpleMeteringClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Simple Metering Cluster Server Default Response * * This function is called when the server receives the default response from @@ -18671,9 +16819,7 @@ void emberAfSimpleMeteringClusterServerAttributeChangedCallback(uint8_t endpoint * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSimpleMeteringClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSimpleMeteringClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Simple Metering Cluster Server Init * * Server Init @@ -18687,7 +16833,7 @@ void emberAfSimpleMeteringClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSimpleMeteringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -18705,11 +16851,8 @@ void emberAfSimpleMeteringClusterServerManufacturerSpecificAttributeChangedCallb * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSimpleMeteringClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSimpleMeteringClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Simple Metering Cluster Server Pre Attribute Changed * @@ -18721,11 +16864,9 @@ void emberAfSimpleMeteringClusterServerMessageSentCallback(EmberOutgoingMessageT * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSimpleMeteringClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSimpleMeteringClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Simple Metering Cluster Server Tick * * Server Tick @@ -18735,7 +16876,7 @@ EmberAfStatus emberAfSimpleMeteringClusterServerPreAttributeChangedCallback(uint void emberAfSimpleMeteringClusterServerTickCallback(uint8_t endpoint); /** @brief Simple Metering Cluster Set Supply Status * - * + * * * @param issuerEventId Ver.: always * @param supplyTamperState Ver.: always @@ -18743,14 +16884,12 @@ void emberAfSimpleMeteringClusterServerTickCallback(uint8_t endpoint); * @param supplyUncontrolledFlowState Ver.: always * @param loadLimitSupplyState Ver.: always */ -bool emberAfSimpleMeteringClusterSetSupplyStatusCallback(uint32_t issuerEventId, - uint8_t supplyTamperState, - uint8_t supplyDepletionState, - uint8_t supplyUncontrolledFlowState, - uint8_t loadLimitSupplyState); +bool emberAfSimpleMeteringClusterSetSupplyStatusCallback(uint32_t issuerEventId, uint8_t supplyTamperState, + uint8_t supplyDepletionState, uint8_t supplyUncontrolledFlowState, + uint8_t loadLimitSupplyState); /** @brief Simple Metering Cluster Set Uncontrolled Flow Threshold * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -18761,17 +16900,13 @@ bool emberAfSimpleMeteringClusterSetSupplyStatusCallback(uint32_t issuerEventId, * @param stabilisationPeriod Ver.: always * @param measurementPeriod Ver.: always */ -bool emberAfSimpleMeteringClusterSetUncontrolledFlowThresholdCallback(uint32_t providerId, - uint32_t issuerEventId, - uint16_t uncontrolledFlowThreshold, - uint8_t unitOfMeasure, - uint16_t multiplier, - uint16_t divisor, - uint8_t stabilisationPeriod, - uint16_t measurementPeriod); +bool emberAfSimpleMeteringClusterSetUncontrolledFlowThresholdCallback(uint32_t providerId, uint32_t issuerEventId, + uint16_t uncontrolledFlowThreshold, uint8_t unitOfMeasure, + uint16_t multiplier, uint16_t divisor, + uint8_t stabilisationPeriod, uint16_t measurementPeriod); /** @brief Simple Metering Cluster Start Sampling * - * + * * * @param issuerEventId Ver.: always * @param startSamplingTime Ver.: always @@ -18779,47 +16914,41 @@ bool emberAfSimpleMeteringClusterSetUncontrolledFlowThresholdCallback(uint32_t p * @param sampleRequestInterval Ver.: always * @param maxNumberOfSamples Ver.: always */ -bool emberAfSimpleMeteringClusterStartSamplingCallback(uint32_t issuerEventId, - uint32_t startSamplingTime, - uint8_t sampleType, - uint16_t sampleRequestInterval, - uint16_t maxNumberOfSamples); +bool emberAfSimpleMeteringClusterStartSamplingCallback(uint32_t issuerEventId, uint32_t startSamplingTime, uint8_t sampleType, + uint16_t sampleRequestInterval, uint16_t maxNumberOfSamples); /** @brief Simple Metering Cluster Start Sampling Response * - * + * * * @param sampleId Ver.: always */ bool emberAfSimpleMeteringClusterStartSamplingResponseCallback(uint16_t sampleId); /** @brief Simple Metering Cluster Supply Status Response * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always * @param implementationDateTime Ver.: always * @param supplyStatus Ver.: always */ -bool emberAfSimpleMeteringClusterSupplyStatusResponseCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t implementationDateTime, - uint8_t supplyStatus); +bool emberAfSimpleMeteringClusterSupplyStatusResponseCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t implementationDateTime, uint8_t supplyStatus); /** @brief Simple Metering Cluster Take Snapshot * - * + * * * @param snapshotCause Ver.: always */ bool emberAfSimpleMeteringClusterTakeSnapshotCallback(uint32_t snapshotCause); /** @brief Simple Metering Cluster Take Snapshot Response * - * + * * * @param snapshotId Ver.: always * @param snapshotConfirmation Ver.: always */ -bool emberAfSimpleMeteringClusterTakeSnapshotResponseCallback(uint32_t snapshotId, - uint8_t snapshotConfirmation); +bool emberAfSimpleMeteringClusterTakeSnapshotResponseCallback(uint32_t snapshotId, uint8_t snapshotConfirmation); /** @} END Simple Metering Cluster Callbacks */ @@ -18828,20 +16957,19 @@ bool emberAfSimpleMeteringClusterTakeSnapshotResponseCallback(uint32_t snapshotI /** @brief Messaging Cluster Cancel All Messages * - * + * * * @param implementationDateTime Ver.: always */ bool emberAfMessagingClusterCancelAllMessagesCallback(uint32_t implementationDateTime); /** @brief Messaging Cluster Cancel Message * - * + * * * @param messageId Ver.: always * @param messageControl Ver.: always */ -bool emberAfMessagingClusterCancelMessageCallback(uint32_t messageId, - uint8_t messageControl); +bool emberAfMessagingClusterCancelMessageCallback(uint32_t messageId, uint8_t messageControl); /** @brief Messaging Cluster Client Attribute Changed * * Client Attribute Changed @@ -18849,8 +16977,7 @@ bool emberAfMessagingClusterCancelMessageCallback(uint32_t messageId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMessagingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMessagingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Messaging Cluster Client Default Response * * This function is called when the client receives the default response from @@ -18860,9 +16987,7 @@ void emberAfMessagingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMessagingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMessagingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Messaging Cluster Client Init * * Client Init @@ -18876,11 +17001,10 @@ void emberAfMessagingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMessagingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMessagingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Messaging Cluster Client Message Sent * @@ -18894,11 +17018,8 @@ void emberAfMessagingClusterClientManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMessagingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMessagingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Messaging Cluster Client Pre Attribute Changed * @@ -18910,11 +17031,9 @@ void emberAfMessagingClusterClientMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMessagingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMessagingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Messaging Cluster Client Tick * * Client Tick @@ -18924,7 +17043,7 @@ EmberAfStatus emberAfMessagingClusterClientPreAttributeChangedCallback(uint8_t e void emberAfMessagingClusterClientTickCallback(uint8_t endpoint); /** @brief Messaging Cluster Display Message * - * + * * * @param messageId Ver.: always * @param messageControl Ver.: always @@ -18933,15 +17052,12 @@ void emberAfMessagingClusterClientTickCallback(uint8_t endpoint); * @param message Ver.: always * @param optionalExtendedMessageControl Ver.: since se-1.2a-07-5356-19 */ -bool emberAfMessagingClusterDisplayMessageCallback(uint32_t messageId, - uint8_t messageControl, - uint32_t startTime, - uint16_t durationInMinutes, - uint8_t* message, - uint8_t optionalExtendedMessageControl); +bool emberAfMessagingClusterDisplayMessageCallback(uint32_t messageId, uint8_t messageControl, uint32_t startTime, + uint16_t durationInMinutes, uint8_t * message, + uint8_t optionalExtendedMessageControl); /** @brief Messaging Cluster Display Protected Message * - * + * * * @param messageId Ver.: always * @param messageControl Ver.: always @@ -18950,38 +17066,33 @@ bool emberAfMessagingClusterDisplayMessageCallback(uint32_t messageId, * @param message Ver.: always * @param optionalExtendedMessageControl Ver.: always */ -bool emberAfMessagingClusterDisplayProtectedMessageCallback(uint32_t messageId, - uint8_t messageControl, - uint32_t startTime, - uint16_t durationInMinutes, - uint8_t* message, - uint8_t optionalExtendedMessageControl); +bool emberAfMessagingClusterDisplayProtectedMessageCallback(uint32_t messageId, uint8_t messageControl, uint32_t startTime, + uint16_t durationInMinutes, uint8_t * message, + uint8_t optionalExtendedMessageControl); /** @brief Messaging Cluster Get Last Message * - * + * * */ bool emberAfMessagingClusterGetLastMessageCallback(void); /** @brief Messaging Cluster Get Message Cancellation * - * + * * * @param earliestImplementationTime Ver.: always */ bool emberAfMessagingClusterGetMessageCancellationCallback(uint32_t earliestImplementationTime); /** @brief Messaging Cluster Message Confirmation * - * + * * * @param messageId Ver.: always * @param confirmationTime Ver.: always * @param messageConfirmationControl Ver.: since se-1.2a-07-5356-19 * @param messageResponse Ver.: since se-1.2a-07-5356-19 */ -bool emberAfMessagingClusterMessageConfirmationCallback(uint32_t messageId, - uint32_t confirmationTime, - uint8_t messageConfirmationControl, - uint8_t* messageResponse); +bool emberAfMessagingClusterMessageConfirmationCallback(uint32_t messageId, uint32_t confirmationTime, + uint8_t messageConfirmationControl, uint8_t * messageResponse); /** @brief Messaging Cluster Server Attribute Changed * * Server Attribute Changed @@ -18989,8 +17100,7 @@ bool emberAfMessagingClusterMessageConfirmationCallback(uint32_t messageId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMessagingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMessagingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Messaging Cluster Server Default Response * * This function is called when the server receives the default response from @@ -19000,9 +17110,7 @@ void emberAfMessagingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMessagingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMessagingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Messaging Cluster Server Init * * Server Init @@ -19016,11 +17124,10 @@ void emberAfMessagingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMessagingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMessagingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Messaging Cluster Server Message Sent * @@ -19034,11 +17141,8 @@ void emberAfMessagingClusterServerManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMessagingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMessagingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Messaging Cluster Server Pre Attribute Changed * @@ -19050,11 +17154,9 @@ void emberAfMessagingClusterServerMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMessagingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMessagingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Messaging Cluster Server Tick * * Server Tick @@ -19070,22 +17172,20 @@ void emberAfMessagingClusterServerTickCallback(uint8_t endpoint); /** @brief Tunneling Cluster Ack Transfer Data Client To Server * - * + * * * @param tunnelId Ver.: always * @param numberOfBytesLeft Ver.: always */ -bool emberAfTunnelingClusterAckTransferDataClientToServerCallback(uint16_t tunnelId, - uint16_t numberOfBytesLeft); +bool emberAfTunnelingClusterAckTransferDataClientToServerCallback(uint16_t tunnelId, uint16_t numberOfBytesLeft); /** @brief Tunneling Cluster Ack Transfer Data Server To Client * - * + * * * @param tunnelId Ver.: always * @param numberOfBytesLeft Ver.: always */ -bool emberAfTunnelingClusterAckTransferDataServerToClientCallback(uint16_t tunnelId, - uint16_t numberOfBytesLeft); +bool emberAfTunnelingClusterAckTransferDataServerToClientCallback(uint16_t tunnelId, uint16_t numberOfBytesLeft); /** @brief Tunneling Cluster Client Attribute Changed * * Client Attribute Changed @@ -19093,8 +17193,7 @@ bool emberAfTunnelingClusterAckTransferDataServerToClientCallback(uint16_t tunne * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTunnelingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTunnelingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Tunneling Cluster Client Default Response * * This function is called when the client receives the default response from @@ -19104,9 +17203,7 @@ void emberAfTunnelingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTunnelingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTunnelingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Tunneling Cluster Client Init * * Client Init @@ -19120,11 +17217,10 @@ void emberAfTunnelingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTunnelingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfTunnelingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Tunneling Cluster Client Message Sent * @@ -19138,11 +17234,8 @@ void emberAfTunnelingClusterClientManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTunnelingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfTunnelingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Tunneling Cluster Client Pre Attribute Changed * @@ -19154,11 +17247,9 @@ void emberAfTunnelingClusterClientMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTunnelingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTunnelingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Tunneling Cluster Client Tick * * Client Tick @@ -19168,60 +17259,55 @@ EmberAfStatus emberAfTunnelingClusterClientPreAttributeChangedCallback(uint8_t e void emberAfTunnelingClusterClientTickCallback(uint8_t endpoint); /** @brief Tunneling Cluster Close Tunnel * - * + * * * @param tunnelId Ver.: always */ bool emberAfTunnelingClusterCloseTunnelCallback(uint16_t tunnelId); /** @brief Tunneling Cluster Get Supported Tunnel Protocols * - * + * * * @param protocolOffset Ver.: always */ bool emberAfTunnelingClusterGetSupportedTunnelProtocolsCallback(uint8_t protocolOffset); /** @brief Tunneling Cluster Ready Data Client To Server * - * + * * * @param tunnelId Ver.: always * @param numberOfOctetsLeft Ver.: always */ -bool emberAfTunnelingClusterReadyDataClientToServerCallback(uint16_t tunnelId, - uint16_t numberOfOctetsLeft); +bool emberAfTunnelingClusterReadyDataClientToServerCallback(uint16_t tunnelId, uint16_t numberOfOctetsLeft); /** @brief Tunneling Cluster Ready Data Server To Client * - * + * * * @param tunnelId Ver.: always * @param numberOfOctetsLeft Ver.: always */ -bool emberAfTunnelingClusterReadyDataServerToClientCallback(uint16_t tunnelId, - uint16_t numberOfOctetsLeft); +bool emberAfTunnelingClusterReadyDataServerToClientCallback(uint16_t tunnelId, uint16_t numberOfOctetsLeft); /** @brief Tunneling Cluster Request Tunnel * - * + * * * @param protocolId Ver.: always * @param manufacturerCode Ver.: always * @param flowControlSupport Ver.: always * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 */ -bool emberAfTunnelingClusterRequestTunnelCallback(uint8_t protocolId, - uint16_t manufacturerCode, - uint8_t flowControlSupport, - uint16_t maximumIncomingTransferSize); +bool emberAfTunnelingClusterRequestTunnelCallback(uint8_t protocolId, uint16_t manufacturerCode, uint8_t flowControlSupport, + uint16_t maximumIncomingTransferSize); /** @brief Tunneling Cluster Request Tunnel Response * - * + * * * @param tunnelId Ver.: always * @param tunnelStatus Ver.: always * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 */ -bool emberAfTunnelingClusterRequestTunnelResponseCallback(uint16_t tunnelId, - uint8_t tunnelStatus, - uint16_t maximumIncomingTransferSize); +bool emberAfTunnelingClusterRequestTunnelResponseCallback(uint16_t tunnelId, uint8_t tunnelStatus, + uint16_t maximumIncomingTransferSize); /** @brief Tunneling Cluster Server Attribute Changed * * Server Attribute Changed @@ -19229,8 +17315,7 @@ bool emberAfTunnelingClusterRequestTunnelResponseCallback(uint16_t tunnelId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfTunnelingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfTunnelingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Tunneling Cluster Server Default Response * * This function is called when the server receives the default response from @@ -19240,9 +17325,7 @@ void emberAfTunnelingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfTunnelingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfTunnelingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Tunneling Cluster Server Init * * Server Init @@ -19256,11 +17339,10 @@ void emberAfTunnelingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfTunnelingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfTunnelingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Tunneling Cluster Server Message Sent * @@ -19274,11 +17356,8 @@ void emberAfTunnelingClusterServerManufacturerSpecificAttributeChangedCallback(u * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfTunnelingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfTunnelingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Tunneling Cluster Server Pre Attribute Changed * @@ -19290,11 +17369,9 @@ void emberAfTunnelingClusterServerMessageSentCallback(EmberOutgoingMessageType t * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfTunnelingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfTunnelingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Tunneling Cluster Server Tick * * Server Tick @@ -19304,54 +17381,49 @@ EmberAfStatus emberAfTunnelingClusterServerPreAttributeChangedCallback(uint8_t e void emberAfTunnelingClusterServerTickCallback(uint8_t endpoint); /** @brief Tunneling Cluster Supported Tunnel Protocols Response * - * + * * * @param protocolListComplete Ver.: always * @param protocolCount Ver.: always * @param protocolList Ver.: always */ -bool emberAfTunnelingClusterSupportedTunnelProtocolsResponseCallback(uint8_t protocolListComplete, - uint8_t protocolCount, - uint8_t* protocolList); +bool emberAfTunnelingClusterSupportedTunnelProtocolsResponseCallback(uint8_t protocolListComplete, uint8_t protocolCount, + uint8_t * protocolList); /** @brief Tunneling Cluster Transfer Data Client To Server * - * + * * * @param tunnelId Ver.: always * @param data Ver.: always */ -bool emberAfTunnelingClusterTransferDataClientToServerCallback(uint16_t tunnelId, - uint8_t* data); +bool emberAfTunnelingClusterTransferDataClientToServerCallback(uint16_t tunnelId, uint8_t * data); /** @brief Tunneling Cluster Transfer Data Error Client To Server * - * + * * * @param tunnelId Ver.: always * @param transferDataStatus Ver.: always */ -bool emberAfTunnelingClusterTransferDataErrorClientToServerCallback(uint16_t tunnelId, - uint8_t transferDataStatus); +bool emberAfTunnelingClusterTransferDataErrorClientToServerCallback(uint16_t tunnelId, uint8_t transferDataStatus); /** @brief Tunneling Cluster Transfer Data Error Server To Client * - * + * * * @param tunnelId Ver.: always * @param transferDataStatus Ver.: always */ -bool emberAfTunnelingClusterTransferDataErrorServerToClientCallback(uint16_t tunnelId, - uint8_t transferDataStatus); +bool emberAfTunnelingClusterTransferDataErrorServerToClientCallback(uint16_t tunnelId, uint8_t transferDataStatus); /** @brief Tunneling Cluster Transfer Data Server To Client * - * + * * * @param tunnelId Ver.: always * @param data Ver.: always */ -bool emberAfTunnelingClusterTransferDataServerToClientCallback(uint16_t tunnelId, - uint8_t* data); +bool emberAfTunnelingClusterTransferDataServerToClientCallback(uint16_t tunnelId, uint8_t * data); /** @brief Tunneling Cluster Tunnel Closure Notification * - * + * * * @param tunnelId Ver.: always */ @@ -19364,7 +17436,7 @@ bool emberAfTunnelingClusterTunnelClosureNotificationCallback(uint16_t tunnelId) /** @brief Prepayment Cluster Change Debt * - * + * * * @param issuerEventId Ver.: always * @param debtLabel Ver.: always @@ -19377,19 +17449,13 @@ bool emberAfTunnelingClusterTunnelClosureNotificationCallback(uint16_t tunnelId) * @param debtRecoveryAmount Ver.: always * @param debtRecoveryBalancePercentage Ver.: always */ -bool emberAfPrepaymentClusterChangeDebtCallback(uint32_t issuerEventId, - uint8_t* debtLabel, - uint32_t debtAmount, - uint8_t debtRecoveryMethod, - uint8_t debtAmountType, - uint32_t debtRecoveryStartTime, - uint16_t debtRecoveryCollectionTime, - uint8_t debtRecoveryFrequency, - uint32_t debtRecoveryAmount, - uint16_t debtRecoveryBalancePercentage); +bool emberAfPrepaymentClusterChangeDebtCallback(uint32_t issuerEventId, uint8_t * debtLabel, uint32_t debtAmount, + uint8_t debtRecoveryMethod, uint8_t debtAmountType, uint32_t debtRecoveryStartTime, + uint16_t debtRecoveryCollectionTime, uint8_t debtRecoveryFrequency, + uint32_t debtRecoveryAmount, uint16_t debtRecoveryBalancePercentage); /** @brief Prepayment Cluster Change Payment Mode * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -19397,24 +17463,19 @@ bool emberAfPrepaymentClusterChangeDebtCallback(uint32_t issuerEventId, * @param proposedPaymentControlConfiguration Ver.: always * @param cutOffValue Ver.: always */ -bool emberAfPrepaymentClusterChangePaymentModeCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t implementationDateTime, - uint16_t proposedPaymentControlConfiguration, - uint32_t cutOffValue); +bool emberAfPrepaymentClusterChangePaymentModeCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t implementationDateTime, + uint16_t proposedPaymentControlConfiguration, uint32_t cutOffValue); /** @brief Prepayment Cluster Change Payment Mode Response * - * + * * * @param friendlyCredit Ver.: always * @param friendlyCreditCalendarId Ver.: always * @param emergencyCreditLimit Ver.: always * @param emergencyCreditThreshold Ver.: always */ -bool emberAfPrepaymentClusterChangePaymentModeResponseCallback(uint8_t friendlyCredit, - uint32_t friendlyCreditCalendarId, - uint32_t emergencyCreditLimit, - uint32_t emergencyCreditThreshold); +bool emberAfPrepaymentClusterChangePaymentModeResponseCallback(uint8_t friendlyCredit, uint32_t friendlyCreditCalendarId, + uint32_t emergencyCreditLimit, uint32_t emergencyCreditThreshold); /** @brief Prepayment Cluster Client Attribute Changed * * Client Attribute Changed @@ -19422,8 +17483,7 @@ bool emberAfPrepaymentClusterChangePaymentModeResponseCallback(uint8_t friendlyC * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPrepaymentClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPrepaymentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Prepayment Cluster Client Default Response * * This function is called when the client receives the default response from @@ -19433,9 +17493,7 @@ void emberAfPrepaymentClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPrepaymentClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPrepaymentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Prepayment Cluster Client Init * * Client Init @@ -19449,11 +17507,10 @@ void emberAfPrepaymentClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPrepaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPrepaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Prepayment Cluster Client Message Sent * @@ -19467,11 +17524,8 @@ void emberAfPrepaymentClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPrepaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPrepaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Prepayment Cluster Client Pre Attribute Changed * @@ -19483,11 +17537,9 @@ void emberAfPrepaymentClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPrepaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPrepaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Prepayment Cluster Client Tick * * Client Tick @@ -19497,99 +17549,85 @@ EmberAfStatus emberAfPrepaymentClusterClientPreAttributeChangedCallback(uint8_t void emberAfPrepaymentClusterClientTickCallback(uint8_t endpoint); /** @brief Prepayment Cluster Consumer Top Up * - * + * * * @param originatingDevice Ver.: always * @param topUpCode Ver.: always */ -bool emberAfPrepaymentClusterConsumerTopUpCallback(uint8_t originatingDevice, - uint8_t* topUpCode); +bool emberAfPrepaymentClusterConsumerTopUpCallback(uint8_t originatingDevice, uint8_t * topUpCode); /** @brief Prepayment Cluster Consumer Top Up Response * - * + * * * @param resultType Ver.: always * @param topUpValue Ver.: always * @param sourceOfTopUp Ver.: always * @param creditRemaining Ver.: always */ -bool emberAfPrepaymentClusterConsumerTopUpResponseCallback(uint8_t resultType, - uint32_t topUpValue, - uint8_t sourceOfTopUp, - uint32_t creditRemaining); +bool emberAfPrepaymentClusterConsumerTopUpResponseCallback(uint8_t resultType, uint32_t topUpValue, uint8_t sourceOfTopUp, + uint32_t creditRemaining); /** @brief Prepayment Cluster Credit Adjustment * - * + * * * @param issuerEventId Ver.: always * @param startTime Ver.: always * @param creditAdjustmentType Ver.: always * @param creditAdjustmentValue Ver.: always */ -bool emberAfPrepaymentClusterCreditAdjustmentCallback(uint32_t issuerEventId, - uint32_t startTime, - uint8_t creditAdjustmentType, - uint32_t creditAdjustmentValue); +bool emberAfPrepaymentClusterCreditAdjustmentCallback(uint32_t issuerEventId, uint32_t startTime, uint8_t creditAdjustmentType, + uint32_t creditAdjustmentValue); /** @brief Prepayment Cluster Emergency Credit Setup * - * + * * * @param issuerEventId Ver.: always * @param startTime Ver.: always * @param emergencyCreditLimit Ver.: always * @param emergencyCreditThreshold Ver.: always */ -bool emberAfPrepaymentClusterEmergencyCreditSetupCallback(uint32_t issuerEventId, - uint32_t startTime, - uint32_t emergencyCreditLimit, - uint32_t emergencyCreditThreshold); +bool emberAfPrepaymentClusterEmergencyCreditSetupCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t emergencyCreditLimit, + uint32_t emergencyCreditThreshold); /** @brief Prepayment Cluster Get Debt Repayment Log * - * + * * * @param latestEndTime Ver.: always * @param numberOfDebts Ver.: always * @param debtType Ver.: always */ -bool emberAfPrepaymentClusterGetDebtRepaymentLogCallback(uint32_t latestEndTime, - uint8_t numberOfDebts, - uint8_t debtType); +bool emberAfPrepaymentClusterGetDebtRepaymentLogCallback(uint32_t latestEndTime, uint8_t numberOfDebts, uint8_t debtType); /** @brief Prepayment Cluster Get Prepay Snapshot * - * + * * * @param earliestStartTime Ver.: always * @param latestEndTime Ver.: always * @param snapshotOffset Ver.: always * @param snapshotCause Ver.: always */ -bool emberAfPrepaymentClusterGetPrepaySnapshotCallback(uint32_t earliestStartTime, - uint32_t latestEndTime, - uint8_t snapshotOffset, - uint32_t snapshotCause); +bool emberAfPrepaymentClusterGetPrepaySnapshotCallback(uint32_t earliestStartTime, uint32_t latestEndTime, uint8_t snapshotOffset, + uint32_t snapshotCause); /** @brief Prepayment Cluster Get Top Up Log * - * + * * * @param latestEndTime Ver.: always * @param numberOfRecords Ver.: always */ -bool emberAfPrepaymentClusterGetTopUpLogCallback(uint32_t latestEndTime, - uint8_t numberOfRecords); +bool emberAfPrepaymentClusterGetTopUpLogCallback(uint32_t latestEndTime, uint8_t numberOfRecords); /** @brief Prepayment Cluster Publish Debt Log * - * + * * * @param commandIndex Ver.: always * @param totalNumberOfCommands Ver.: always * @param debtPayload Ver.: always */ -bool emberAfPrepaymentClusterPublishDebtLogCallback(uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t* debtPayload); +bool emberAfPrepaymentClusterPublishDebtLogCallback(uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * debtPayload); /** @brief Prepayment Cluster Publish Prepay Snapshot * - * + * * * @param snapshotId Ver.: always * @param snapshotTime Ver.: always @@ -19600,34 +17638,27 @@ bool emberAfPrepaymentClusterPublishDebtLogCallback(uint8_t commandIndex, * @param snapshotPayloadType Ver.: always * @param snapshotPayload Ver.: always */ -bool emberAfPrepaymentClusterPublishPrepaySnapshotCallback(uint32_t snapshotId, - uint32_t snapshotTime, - uint8_t totalSnapshotsFound, - uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint32_t snapshotCause, - uint8_t snapshotPayloadType, - uint8_t* snapshotPayload); +bool emberAfPrepaymentClusterPublishPrepaySnapshotCallback(uint32_t snapshotId, uint32_t snapshotTime, uint8_t totalSnapshotsFound, + uint8_t commandIndex, uint8_t totalNumberOfCommands, + uint32_t snapshotCause, uint8_t snapshotPayloadType, + uint8_t * snapshotPayload); /** @brief Prepayment Cluster Publish Top Up Log * - * + * * * @param commandIndex Ver.: always * @param totalNumberOfCommands Ver.: always * @param topUpPayload Ver.: always */ -bool emberAfPrepaymentClusterPublishTopUpLogCallback(uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t* topUpPayload); +bool emberAfPrepaymentClusterPublishTopUpLogCallback(uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * topUpPayload); /** @brief Prepayment Cluster Select Available Emergency Credit * - * + * * * @param commandIssueDateTime Ver.: always * @param originatingDevice Ver.: always */ -bool emberAfPrepaymentClusterSelectAvailableEmergencyCreditCallback(uint32_t commandIssueDateTime, - uint8_t originatingDevice); +bool emberAfPrepaymentClusterSelectAvailableEmergencyCreditCallback(uint32_t commandIssueDateTime, uint8_t originatingDevice); /** @brief Prepayment Cluster Server Attribute Changed * * Server Attribute Changed @@ -19635,8 +17666,7 @@ bool emberAfPrepaymentClusterSelectAvailableEmergencyCreditCallback(uint32_t com * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPrepaymentClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPrepaymentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Prepayment Cluster Server Default Response * * This function is called when the server receives the default response from @@ -19646,9 +17676,7 @@ void emberAfPrepaymentClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPrepaymentClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPrepaymentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Prepayment Cluster Server Init * * Server Init @@ -19662,11 +17690,10 @@ void emberAfPrepaymentClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPrepaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPrepaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Prepayment Cluster Server Message Sent * @@ -19680,11 +17707,8 @@ void emberAfPrepaymentClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPrepaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPrepaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Prepayment Cluster Server Pre Attribute Changed * @@ -19696,11 +17720,9 @@ void emberAfPrepaymentClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPrepaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPrepaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Prepayment Cluster Server Tick * * Server Tick @@ -19710,14 +17732,14 @@ EmberAfStatus emberAfPrepaymentClusterServerPreAttributeChangedCallback(uint8_t void emberAfPrepaymentClusterServerTickCallback(uint8_t endpoint); /** @brief Prepayment Cluster Set Low Credit Warning Level * - * + * * * @param lowCreditWarningLevel Ver.: always */ bool emberAfPrepaymentClusterSetLowCreditWarningLevelCallback(uint32_t lowCreditWarningLevel); /** @brief Prepayment Cluster Set Maximum Credit Limit * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -19725,24 +17747,20 @@ bool emberAfPrepaymentClusterSetLowCreditWarningLevelCallback(uint32_t lowCredit * @param maximumCreditLevel Ver.: always * @param maximumCreditPerTopUp Ver.: always */ -bool emberAfPrepaymentClusterSetMaximumCreditLimitCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t implementationDateTime, - uint32_t maximumCreditLevel, - uint32_t maximumCreditPerTopUp); +bool emberAfPrepaymentClusterSetMaximumCreditLimitCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t implementationDateTime, uint32_t maximumCreditLevel, + uint32_t maximumCreditPerTopUp); /** @brief Prepayment Cluster Set Overall Debt Cap * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always * @param implementationDateTime Ver.: always * @param overallDebtCap Ver.: always */ -bool emberAfPrepaymentClusterSetOverallDebtCapCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t implementationDateTime, - uint32_t overallDebtCap); +bool emberAfPrepaymentClusterSetOverallDebtCapCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t implementationDateTime, + uint32_t overallDebtCap); /** @} END Prepayment Cluster Callbacks */ @@ -19756,8 +17774,7 @@ bool emberAfPrepaymentClusterSetOverallDebtCapCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEnergyManagementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEnergyManagementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Energy Management Cluster Client Default Response * * This function is called when the client receives the default response from @@ -19767,9 +17784,7 @@ void emberAfEnergyManagementClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEnergyManagementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfEnergyManagementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Energy Management Cluster Client Init * * Client Init @@ -19783,7 +17798,7 @@ void emberAfEnergyManagementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfEnergyManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -19801,11 +17816,8 @@ void emberAfEnergyManagementClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfEnergyManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfEnergyManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Energy Management Cluster Client Pre Attribute Changed * @@ -19817,11 +17829,9 @@ void emberAfEnergyManagementClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEnergyManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEnergyManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Energy Management Cluster Client Tick * * Client Tick @@ -19831,20 +17841,18 @@ EmberAfStatus emberAfEnergyManagementClusterClientPreAttributeChangedCallback(ui void emberAfEnergyManagementClusterClientTickCallback(uint8_t endpoint); /** @brief Energy Management Cluster Manage Event * - * + * * * @param issuerEventId Ver.: always * @param deviceClass Ver.: always * @param utilityEnrollmentGroup Ver.: always * @param actionRequired Ver.: always */ -bool emberAfEnergyManagementClusterManageEventCallback(uint32_t issuerEventId, - uint16_t deviceClass, - uint8_t utilityEnrollmentGroup, - uint8_t actionRequired); +bool emberAfEnergyManagementClusterManageEventCallback(uint32_t issuerEventId, uint16_t deviceClass, uint8_t utilityEnrollmentGroup, + uint8_t actionRequired); /** @brief Energy Management Cluster Report Event Status * - * + * * * @param issuerEventId Ver.: always * @param eventStatus Ver.: always @@ -19856,15 +17864,12 @@ bool emberAfEnergyManagementClusterManageEventCallback(uint32_t issuerEventId, * @param dutyCycleApplied Ver.: always * @param eventControl Ver.: always */ -bool emberAfEnergyManagementClusterReportEventStatusCallback(uint32_t issuerEventId, - uint8_t eventStatus, - uint32_t eventStatusTime, - uint8_t criticalityLevelApplied, - uint16_t coolingTemperatureSetPointApplied, - uint16_t heatingTemperatureSetPointApplied, - int8_t averageLoadAdjustmentPercentageApplied, - uint8_t dutyCycleApplied, - uint8_t eventControl); +bool emberAfEnergyManagementClusterReportEventStatusCallback(uint32_t issuerEventId, uint8_t eventStatus, uint32_t eventStatusTime, + uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, uint8_t eventControl); /** @brief Energy Management Cluster Server Attribute Changed * * Server Attribute Changed @@ -19872,8 +17877,7 @@ bool emberAfEnergyManagementClusterReportEventStatusCallback(uint32_t issuerEven * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEnergyManagementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEnergyManagementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Energy Management Cluster Server Default Response * * This function is called when the server receives the default response from @@ -19883,9 +17887,7 @@ void emberAfEnergyManagementClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEnergyManagementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfEnergyManagementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Energy Management Cluster Server Init * * Server Init @@ -19899,7 +17901,7 @@ void emberAfEnergyManagementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfEnergyManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -19917,11 +17919,8 @@ void emberAfEnergyManagementClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfEnergyManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfEnergyManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Energy Management Cluster Server Pre Attribute Changed * @@ -19933,11 +17932,9 @@ void emberAfEnergyManagementClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEnergyManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEnergyManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Energy Management Cluster Server Tick * * Server Tick @@ -19953,15 +17950,13 @@ void emberAfEnergyManagementClusterServerTickCallback(uint8_t endpoint); /** @brief Calendar Cluster Cancel Calendar * - * + * * * @param providerId Ver.: always * @param issuerCalendarId Ver.: always * @param calendarType Ver.: always */ -bool emberAfCalendarClusterCancelCalendarCallback(uint32_t providerId, - uint32_t issuerCalendarId, - uint8_t calendarType); +bool emberAfCalendarClusterCancelCalendarCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t calendarType); /** @brief Calendar Cluster Client Attribute Changed * * Client Attribute Changed @@ -19969,8 +17964,7 @@ bool emberAfCalendarClusterCancelCalendarCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCalendarClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCalendarClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Calendar Cluster Client Default Response * * This function is called when the client receives the default response from @@ -19980,9 +17974,7 @@ void emberAfCalendarClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCalendarClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfCalendarClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Calendar Cluster Client Init * * Client Init @@ -19996,11 +17988,10 @@ void emberAfCalendarClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCalendarClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfCalendarClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Calendar Cluster Client Message Sent * @@ -20014,11 +18005,8 @@ void emberAfCalendarClusterClientManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfCalendarClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfCalendarClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Calendar Cluster Client Pre Attribute Changed * @@ -20030,11 +18018,9 @@ void emberAfCalendarClusterClientMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCalendarClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCalendarClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Calendar Cluster Client Tick * * Client Tick @@ -20044,7 +18030,7 @@ EmberAfStatus emberAfCalendarClusterClientPreAttributeChangedCallback(uint8_t en void emberAfCalendarClusterClientTickCallback(uint8_t endpoint); /** @brief Calendar Cluster Get Calendar * - * + * * * @param earliestStartTime Ver.: always * @param minIssuerEventId Ver.: always @@ -20052,42 +18038,36 @@ void emberAfCalendarClusterClientTickCallback(uint8_t endpoint); * @param calendarType Ver.: always * @param providerId Ver.: always */ -bool emberAfCalendarClusterGetCalendarCallback(uint32_t earliestStartTime, - uint32_t minIssuerEventId, - uint8_t numberOfCalendars, - uint8_t calendarType, - uint32_t providerId); +bool emberAfCalendarClusterGetCalendarCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCalendars, + uint8_t calendarType, uint32_t providerId); /** @brief Calendar Cluster Get Calendar Cancellation * - * + * * */ bool emberAfCalendarClusterGetCalendarCancellationCallback(void); /** @brief Calendar Cluster Get Day Profiles * - * + * * * @param providerId Ver.: always * @param issuerCalendarId Ver.: always * @param startDayId Ver.: always * @param numberOfDays Ver.: always */ -bool emberAfCalendarClusterGetDayProfilesCallback(uint32_t providerId, - uint32_t issuerCalendarId, - uint8_t startDayId, - uint8_t numberOfDays); +bool emberAfCalendarClusterGetDayProfilesCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t startDayId, + uint8_t numberOfDays); /** @brief Calendar Cluster Get Seasons * - * + * * * @param providerId Ver.: always * @param issuerCalendarId Ver.: always */ -bool emberAfCalendarClusterGetSeasonsCallback(uint32_t providerId, - uint32_t issuerCalendarId); +bool emberAfCalendarClusterGetSeasonsCallback(uint32_t providerId, uint32_t issuerCalendarId); /** @brief Calendar Cluster Get Special Days * - * + * * * @param startTime Ver.: always * @param numberOfEvents Ver.: always @@ -20095,27 +18075,22 @@ bool emberAfCalendarClusterGetSeasonsCallback(uint32_t providerId, * @param providerId Ver.: always * @param issuerCalendarId Ver.: always */ -bool emberAfCalendarClusterGetSpecialDaysCallback(uint32_t startTime, - uint8_t numberOfEvents, - uint8_t calendarType, - uint32_t providerId, - uint32_t issuerCalendarId); +bool emberAfCalendarClusterGetSpecialDaysCallback(uint32_t startTime, uint8_t numberOfEvents, uint8_t calendarType, + uint32_t providerId, uint32_t issuerCalendarId); /** @brief Calendar Cluster Get Week Profiles * - * + * * * @param providerId Ver.: always * @param issuerCalendarId Ver.: always * @param startWeekId Ver.: always * @param numberOfWeeks Ver.: always */ -bool emberAfCalendarClusterGetWeekProfilesCallback(uint32_t providerId, - uint32_t issuerCalendarId, - uint8_t startWeekId, - uint8_t numberOfWeeks); +bool emberAfCalendarClusterGetWeekProfilesCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t startWeekId, + uint8_t numberOfWeeks); /** @brief Calendar Cluster Publish Calendar * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20128,19 +18103,13 @@ bool emberAfCalendarClusterGetWeekProfilesCallback(uint32_t providerId, * @param numberOfWeekProfiles Ver.: always * @param numberOfDayProfiles Ver.: always */ -bool emberAfCalendarClusterPublishCalendarCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerCalendarId, - uint32_t startTime, - uint8_t calendarType, - uint8_t calendarTimeReference, - uint8_t* calendarName, - uint8_t numberOfSeasons, - uint8_t numberOfWeekProfiles, - uint8_t numberOfDayProfiles); +bool emberAfCalendarClusterPublishCalendarCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint32_t startTime, uint8_t calendarType, uint8_t calendarTimeReference, + uint8_t * calendarName, uint8_t numberOfSeasons, uint8_t numberOfWeekProfiles, + uint8_t numberOfDayProfiles); /** @brief Calendar Cluster Publish Day Profile * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20152,18 +18121,13 @@ bool emberAfCalendarClusterPublishCalendarCallback(uint32_t providerId, * @param calendarType Ver.: always * @param dayScheduleEntries Ver.: always */ -bool emberAfCalendarClusterPublishDayProfileCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerCalendarId, - uint8_t dayId, - uint8_t totalNumberOfScheduleEntries, - uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t calendarType, - uint8_t* dayScheduleEntries); +bool emberAfCalendarClusterPublishDayProfileCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t dayId, uint8_t totalNumberOfScheduleEntries, uint8_t commandIndex, + uint8_t totalNumberOfCommands, uint8_t calendarType, + uint8_t * dayScheduleEntries); /** @brief Calendar Cluster Publish Seasons * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20172,15 +18136,11 @@ bool emberAfCalendarClusterPublishDayProfileCallback(uint32_t providerId, * @param totalNumberOfCommands Ver.: always * @param seasonEntries Ver.: always */ -bool emberAfCalendarClusterPublishSeasonsCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerCalendarId, - uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t* seasonEntries); +bool emberAfCalendarClusterPublishSeasonsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * seasonEntries); /** @brief Calendar Cluster Publish Special Days * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20192,18 +18152,13 @@ bool emberAfCalendarClusterPublishSeasonsCallback(uint32_t providerId, * @param totalNumberOfCommands Ver.: always * @param specialDayEntries Ver.: always */ -bool emberAfCalendarClusterPublishSpecialDaysCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerCalendarId, - uint32_t startTime, - uint8_t calendarType, - uint8_t totalNumberOfSpecialDays, - uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t* specialDayEntries); +bool emberAfCalendarClusterPublishSpecialDaysCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint32_t startTime, uint8_t calendarType, uint8_t totalNumberOfSpecialDays, + uint8_t commandIndex, uint8_t totalNumberOfCommands, + uint8_t * specialDayEntries); /** @brief Calendar Cluster Publish Week Profile * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20217,17 +18172,10 @@ bool emberAfCalendarClusterPublishSpecialDaysCallback(uint32_t providerId, * @param dayIdRefSaturday Ver.: always * @param dayIdRefSunday Ver.: always */ -bool emberAfCalendarClusterPublishWeekProfileCallback(uint32_t providerId, - uint32_t issuerEventId, - uint32_t issuerCalendarId, - uint8_t weekId, - uint8_t dayIdRefMonday, - uint8_t dayIdRefTuesday, - uint8_t dayIdRefWednesday, - uint8_t dayIdRefThursday, - uint8_t dayIdRefFriday, - uint8_t dayIdRefSaturday, - uint8_t dayIdRefSunday); +bool emberAfCalendarClusterPublishWeekProfileCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t weekId, uint8_t dayIdRefMonday, uint8_t dayIdRefTuesday, + uint8_t dayIdRefWednesday, uint8_t dayIdRefThursday, uint8_t dayIdRefFriday, + uint8_t dayIdRefSaturday, uint8_t dayIdRefSunday); /** @brief Calendar Cluster Server Attribute Changed * * Server Attribute Changed @@ -20235,8 +18183,7 @@ bool emberAfCalendarClusterPublishWeekProfileCallback(uint32_t providerId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfCalendarClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfCalendarClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Calendar Cluster Server Default Response * * This function is called when the server receives the default response from @@ -20246,9 +18193,7 @@ void emberAfCalendarClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfCalendarClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfCalendarClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Calendar Cluster Server Init * * Server Init @@ -20262,11 +18207,10 @@ void emberAfCalendarClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfCalendarClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfCalendarClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Calendar Cluster Server Message Sent * @@ -20280,11 +18224,8 @@ void emberAfCalendarClusterServerManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfCalendarClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfCalendarClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Calendar Cluster Server Pre Attribute Changed * @@ -20296,11 +18237,9 @@ void emberAfCalendarClusterServerMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfCalendarClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfCalendarClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Calendar Cluster Server Tick * * Server Tick @@ -20321,8 +18260,7 @@ void emberAfCalendarClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDeviceManagementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDeviceManagementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Device Management Cluster Client Default Response * * This function is called when the client receives the default response from @@ -20332,9 +18270,7 @@ void emberAfDeviceManagementClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDeviceManagementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDeviceManagementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Device Management Cluster Client Init * * Client Init @@ -20348,7 +18284,7 @@ void emberAfDeviceManagementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDeviceManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -20366,11 +18302,8 @@ void emberAfDeviceManagementClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDeviceManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDeviceManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Device Management Cluster Client Pre Attribute Changed * @@ -20382,11 +18315,9 @@ void emberAfDeviceManagementClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDeviceManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDeviceManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Device Management Cluster Client Tick * * Client Tick @@ -20396,38 +18327,38 @@ EmberAfStatus emberAfDeviceManagementClusterClientPreAttributeChangedCallback(ui void emberAfDeviceManagementClusterClientTickCallback(uint8_t endpoint); /** @brief Device Management Cluster Get C I N * - * + * * */ bool emberAfDeviceManagementClusterGetCINCallback(void); /** @brief Device Management Cluster Get Change Of Supplier * - * + * * */ bool emberAfDeviceManagementClusterGetChangeOfSupplierCallback(void); /** @brief Device Management Cluster Get Change Of Tenancy * - * + * * */ bool emberAfDeviceManagementClusterGetChangeOfTenancyCallback(void); /** @brief Device Management Cluster Get Event Configuration * - * + * * * @param eventId Ver.: always */ bool emberAfDeviceManagementClusterGetEventConfigurationCallback(uint16_t eventId); /** @brief Device Management Cluster Get Site Id * - * + * * */ bool emberAfDeviceManagementClusterGetSiteIdCallback(void); /** @brief Device Management Cluster Publish Change Of Supplier * - * + * * * @param currentProviderId Ver.: always * @param issuerEventId Ver.: always @@ -20438,17 +18369,14 @@ bool emberAfDeviceManagementClusterGetSiteIdCallback(void); * @param proposedProviderName Ver.: always * @param proposedProviderContactDetails Ver.: always */ -bool emberAfDeviceManagementClusterPublishChangeOfSupplierCallback(uint32_t currentProviderId, - uint32_t issuerEventId, - uint8_t tariffType, - uint32_t proposedProviderId, - uint32_t providerChangeImplementationTime, - uint32_t providerChangeControl, - uint8_t* proposedProviderName, - uint8_t* proposedProviderContactDetails); +bool emberAfDeviceManagementClusterPublishChangeOfSupplierCallback(uint32_t currentProviderId, uint32_t issuerEventId, + uint8_t tariffType, uint32_t proposedProviderId, + uint32_t providerChangeImplementationTime, + uint32_t providerChangeControl, uint8_t * proposedProviderName, + uint8_t * proposedProviderContactDetails); /** @brief Device Management Cluster Publish Change Of Tenancy * - * + * * * @param providerId Ver.: always * @param issuerEventId Ver.: always @@ -20456,32 +18384,29 @@ bool emberAfDeviceManagementClusterPublishChangeOfSupplierCallback(uint32_t curr * @param implementationDateTime Ver.: always * @param proposedTenancyChangeControl Ver.: always */ -bool emberAfDeviceManagementClusterPublishChangeOfTenancyCallback(uint32_t providerId, - uint32_t issuerEventId, - uint8_t tariffType, - uint32_t implementationDateTime, - uint32_t proposedTenancyChangeControl); +bool emberAfDeviceManagementClusterPublishChangeOfTenancyCallback(uint32_t providerId, uint32_t issuerEventId, uint8_t tariffType, + uint32_t implementationDateTime, + uint32_t proposedTenancyChangeControl); /** @brief Device Management Cluster Report Event Configuration * - * + * * * @param commandIndex Ver.: always * @param totalCommands Ver.: always * @param eventConfigurationPayload Ver.: always */ -bool emberAfDeviceManagementClusterReportEventConfigurationCallback(uint8_t commandIndex, - uint8_t totalCommands, - uint8_t* eventConfigurationPayload); +bool emberAfDeviceManagementClusterReportEventConfigurationCallback(uint8_t commandIndex, uint8_t totalCommands, + uint8_t * eventConfigurationPayload); /** @brief Device Management Cluster Request New Password * - * + * * * @param passwordType Ver.: always */ bool emberAfDeviceManagementClusterRequestNewPasswordCallback(uint8_t passwordType); /** @brief Device Management Cluster Request New Password Response * - * + * * * @param issuerEventId Ver.: always * @param implementationDateTime Ver.: always @@ -20489,11 +18414,9 @@ bool emberAfDeviceManagementClusterRequestNewPasswordCallback(uint8_t passwordTy * @param passwordType Ver.: always * @param password Ver.: always */ -bool emberAfDeviceManagementClusterRequestNewPasswordResponseCallback(uint32_t issuerEventId, - uint32_t implementationDateTime, - uint16_t durationInMinutes, - uint8_t passwordType, - uint8_t* password); +bool emberAfDeviceManagementClusterRequestNewPasswordResponseCallback(uint32_t issuerEventId, uint32_t implementationDateTime, + uint16_t durationInMinutes, uint8_t passwordType, + uint8_t * password); /** @brief Device Management Cluster Server Attribute Changed * * Server Attribute Changed @@ -20501,8 +18424,7 @@ bool emberAfDeviceManagementClusterRequestNewPasswordResponseCallback(uint32_t i * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDeviceManagementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDeviceManagementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Device Management Cluster Server Default Response * * This function is called when the server receives the default response from @@ -20512,9 +18434,7 @@ void emberAfDeviceManagementClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDeviceManagementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDeviceManagementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Device Management Cluster Server Init * * Server Init @@ -20528,7 +18448,7 @@ void emberAfDeviceManagementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDeviceManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -20546,11 +18466,8 @@ void emberAfDeviceManagementClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDeviceManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDeviceManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Device Management Cluster Server Pre Attribute Changed * @@ -20562,11 +18479,9 @@ void emberAfDeviceManagementClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDeviceManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDeviceManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Device Management Cluster Server Tick * * Server Tick @@ -20576,7 +18491,7 @@ EmberAfStatus emberAfDeviceManagementClusterServerPreAttributeChangedCallback(ui void emberAfDeviceManagementClusterServerTickCallback(uint8_t endpoint); /** @brief Device Management Cluster Set Event Configuration * - * + * * * @param issuerEventId Ver.: always * @param startDateTime Ver.: always @@ -20584,37 +18499,31 @@ void emberAfDeviceManagementClusterServerTickCallback(uint8_t endpoint); * @param configurationControl Ver.: always * @param eventConfigurationPayload Ver.: always */ -bool emberAfDeviceManagementClusterSetEventConfigurationCallback(uint32_t issuerEventId, - uint32_t startDateTime, - uint8_t eventConfiguration, - uint8_t configurationControl, - uint8_t* eventConfigurationPayload); +bool emberAfDeviceManagementClusterSetEventConfigurationCallback(uint32_t issuerEventId, uint32_t startDateTime, + uint8_t eventConfiguration, uint8_t configurationControl, + uint8_t * eventConfigurationPayload); /** @brief Device Management Cluster Update C I N * - * + * * * @param issuerEventId Ver.: always * @param implementationTime Ver.: always * @param providerId Ver.: always * @param customerIdNumber Ver.: always */ -bool emberAfDeviceManagementClusterUpdateCINCallback(uint32_t issuerEventId, - uint32_t implementationTime, - uint32_t providerId, - uint8_t* customerIdNumber); +bool emberAfDeviceManagementClusterUpdateCINCallback(uint32_t issuerEventId, uint32_t implementationTime, uint32_t providerId, + uint8_t * customerIdNumber); /** @brief Device Management Cluster Update Site Id * - * + * * * @param issuerEventId Ver.: always * @param siteIdTime Ver.: always * @param providerId Ver.: always * @param siteId Ver.: always */ -bool emberAfDeviceManagementClusterUpdateSiteIdCallback(uint32_t issuerEventId, - uint32_t siteIdTime, - uint32_t providerId, - uint8_t* siteId); +bool emberAfDeviceManagementClusterUpdateSiteIdCallback(uint32_t issuerEventId, uint32_t siteIdTime, uint32_t providerId, + uint8_t * siteId); /** @} END Device Management Cluster Callbacks */ @@ -20623,14 +18532,14 @@ bool emberAfDeviceManagementClusterUpdateSiteIdCallback(uint32_t issuerEventId, /** @brief Events Cluster Clear Event Log Request * - * + * * * @param logId Ver.: always */ bool emberAfEventsClusterClearEventLogRequestCallback(uint8_t logId); /** @brief Events Cluster Clear Event Log Response * - * + * * * @param clearedEventsLogs Ver.: always */ @@ -20642,8 +18551,7 @@ bool emberAfEventsClusterClearEventLogResponseCallback(uint8_t clearedEventsLogs * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEventsClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEventsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Events Cluster Client Default Response * * This function is called when the client receives the default response from @@ -20653,9 +18561,7 @@ void emberAfEventsClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEventsClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfEventsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Events Cluster Client Init * * Client Init @@ -20669,11 +18575,10 @@ void emberAfEventsClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEventsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfEventsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Events Cluster Client Message Sent * @@ -20687,11 +18592,8 @@ void emberAfEventsClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfEventsClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfEventsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Events Cluster Client Pre Attribute Changed * @@ -20703,11 +18605,9 @@ void emberAfEventsClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEventsClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEventsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Events Cluster Client Tick * * Client Tick @@ -20717,7 +18617,7 @@ EmberAfStatus emberAfEventsClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfEventsClusterClientTickCallback(uint8_t endpoint); /** @brief Events Cluster Get Event Log * - * + * * * @param eventControlLogId Ver.: always * @param eventId Ver.: always @@ -20726,15 +18626,11 @@ void emberAfEventsClusterClientTickCallback(uint8_t endpoint); * @param numberOfEvents Ver.: always * @param eventOffset Ver.: always */ -bool emberAfEventsClusterGetEventLogCallback(uint8_t eventControlLogId, - uint16_t eventId, - uint32_t startTime, - uint32_t endTime, - uint8_t numberOfEvents, - uint16_t eventOffset); +bool emberAfEventsClusterGetEventLogCallback(uint8_t eventControlLogId, uint16_t eventId, uint32_t startTime, uint32_t endTime, + uint8_t numberOfEvents, uint16_t eventOffset); /** @brief Events Cluster Publish Event * - * + * * * @param logId Ver.: always * @param eventId Ver.: always @@ -20742,14 +18638,11 @@ bool emberAfEventsClusterGetEventLogCallback(uint8_t eventControlLogId, * @param eventControl Ver.: always * @param eventData Ver.: always */ -bool emberAfEventsClusterPublishEventCallback(uint8_t logId, - uint16_t eventId, - uint32_t eventTime, - uint8_t eventControl, - uint8_t* eventData); +bool emberAfEventsClusterPublishEventCallback(uint8_t logId, uint16_t eventId, uint32_t eventTime, uint8_t eventControl, + uint8_t * eventData); /** @brief Events Cluster Publish Event Log * - * + * * * @param totalNumberOfEvents Ver.: always * @param commandIndex Ver.: always @@ -20757,11 +18650,8 @@ bool emberAfEventsClusterPublishEventCallback(uint8_t logId, * @param logPayloadControl Ver.: always * @param logPayload Ver.: always */ -bool emberAfEventsClusterPublishEventLogCallback(uint16_t totalNumberOfEvents, - uint8_t commandIndex, - uint8_t totalCommands, - uint8_t logPayloadControl, - uint8_t* logPayload); +bool emberAfEventsClusterPublishEventLogCallback(uint16_t totalNumberOfEvents, uint8_t commandIndex, uint8_t totalCommands, + uint8_t logPayloadControl, uint8_t * logPayload); /** @brief Events Cluster Server Attribute Changed * * Server Attribute Changed @@ -20769,8 +18659,7 @@ bool emberAfEventsClusterPublishEventLogCallback(uint16_t totalNumberOfEvents, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfEventsClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfEventsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Events Cluster Server Default Response * * This function is called when the server receives the default response from @@ -20780,9 +18669,7 @@ void emberAfEventsClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfEventsClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfEventsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Events Cluster Server Init * * Server Init @@ -20796,11 +18683,10 @@ void emberAfEventsClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfEventsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfEventsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Events Cluster Server Message Sent * @@ -20814,11 +18700,8 @@ void emberAfEventsClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfEventsClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfEventsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Events Cluster Server Pre Attribute Changed * @@ -20830,11 +18713,9 @@ void emberAfEventsClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfEventsClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfEventsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Events Cluster Server Tick * * Server Tick @@ -20855,8 +18736,7 @@ void emberAfEventsClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMduPairingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMduPairingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief MDU Pairing Cluster Client Default Response * * This function is called when the client receives the default response from @@ -20866,9 +18746,7 @@ void emberAfMduPairingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMduPairingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMduPairingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief MDU Pairing Cluster Client Init * * Client Init @@ -20882,11 +18760,10 @@ void emberAfMduPairingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMduPairingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMduPairingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief MDU Pairing Cluster Client Message Sent * @@ -20900,11 +18777,8 @@ void emberAfMduPairingClusterClientManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMduPairingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMduPairingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief MDU Pairing Cluster Client Pre Attribute Changed * @@ -20916,11 +18790,9 @@ void emberAfMduPairingClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMduPairingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMduPairingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief MDU Pairing Cluster Client Tick * * Client Tick @@ -20930,16 +18802,15 @@ EmberAfStatus emberAfMduPairingClusterClientPreAttributeChangedCallback(uint8_t void emberAfMduPairingClusterClientTickCallback(uint8_t endpoint); /** @brief MDU Pairing Cluster Pairing Request * - * + * * * @param localPairingInformationVersion Ver.: always * @param eui64OfRequestingDevice Ver.: always */ -bool emberAfMduPairingClusterPairingRequestCallback(uint32_t localPairingInformationVersion, - uint8_t* eui64OfRequestingDevice); +bool emberAfMduPairingClusterPairingRequestCallback(uint32_t localPairingInformationVersion, uint8_t * eui64OfRequestingDevice); /** @brief MDU Pairing Cluster Pairing Response * - * + * * * @param pairingInformationVersion Ver.: always * @param totalNumberOfDevices Ver.: always @@ -20947,11 +18818,8 @@ bool emberAfMduPairingClusterPairingRequestCallback(uint32_t localPairingInforma * @param totalNumberOfCommands Ver.: always * @param eui64s Ver.: always */ -bool emberAfMduPairingClusterPairingResponseCallback(uint32_t pairingInformationVersion, - uint8_t totalNumberOfDevices, - uint8_t commandIndex, - uint8_t totalNumberOfCommands, - uint8_t* eui64s); +bool emberAfMduPairingClusterPairingResponseCallback(uint32_t pairingInformationVersion, uint8_t totalNumberOfDevices, + uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * eui64s); /** @brief MDU Pairing Cluster Server Attribute Changed * * Server Attribute Changed @@ -20959,8 +18827,7 @@ bool emberAfMduPairingClusterPairingResponseCallback(uint32_t pairingInformation * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMduPairingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMduPairingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief MDU Pairing Cluster Server Default Response * * This function is called when the server receives the default response from @@ -20970,9 +18837,7 @@ void emberAfMduPairingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMduPairingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMduPairingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief MDU Pairing Cluster Server Init * * Server Init @@ -20986,11 +18851,10 @@ void emberAfMduPairingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMduPairingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMduPairingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief MDU Pairing Cluster Server Message Sent * @@ -21004,11 +18868,8 @@ void emberAfMduPairingClusterServerManufacturerSpecificAttributeChangedCallback( * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMduPairingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMduPairingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief MDU Pairing Cluster Server Pre Attribute Changed * @@ -21020,11 +18881,9 @@ void emberAfMduPairingClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMduPairingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMduPairingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief MDU Pairing Cluster Server Tick * * Server Tick @@ -21045,8 +18904,7 @@ void emberAfMduPairingClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSubGhzClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSubGhzClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sub-GHz Cluster Client Default Response * * This function is called when the client receives the default response from @@ -21056,9 +18914,7 @@ void emberAfSubGhzClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSubGhzClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSubGhzClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sub-GHz Cluster Client Init * * Client Init @@ -21072,11 +18928,10 @@ void emberAfSubGhzClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSubGhzClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfSubGhzClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Sub-GHz Cluster Client Message Sent * @@ -21090,11 +18945,8 @@ void emberAfSubGhzClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSubGhzClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSubGhzClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sub-GHz Cluster Client Pre Attribute Changed * @@ -21106,11 +18958,9 @@ void emberAfSubGhzClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSubGhzClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSubGhzClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sub-GHz Cluster Client Tick * * Client Tick @@ -21120,7 +18970,7 @@ EmberAfStatus emberAfSubGhzClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfSubGhzClusterClientTickCallback(uint8_t endpoint); /** @brief Sub-GHz Cluster Get Suspend Zcl Messages Status * - * + * * */ bool emberAfSubGhzClusterGetSuspendZclMessagesStatusCallback(void); @@ -21131,8 +18981,7 @@ bool emberAfSubGhzClusterGetSuspendZclMessagesStatusCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSubGhzClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSubGhzClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sub-GHz Cluster Server Default Response * * This function is called when the server receives the default response from @@ -21142,9 +18991,7 @@ void emberAfSubGhzClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSubGhzClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSubGhzClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sub-GHz Cluster Server Init * * Server Init @@ -21158,11 +19005,10 @@ void emberAfSubGhzClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSubGhzClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfSubGhzClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Sub-GHz Cluster Server Message Sent * @@ -21176,11 +19022,8 @@ void emberAfSubGhzClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSubGhzClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSubGhzClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sub-GHz Cluster Server Pre Attribute Changed * @@ -21192,11 +19035,9 @@ void emberAfSubGhzClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSubGhzClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSubGhzClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sub-GHz Cluster Server Tick * * Server Tick @@ -21206,7 +19047,7 @@ EmberAfStatus emberAfSubGhzClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfSubGhzClusterServerTickCallback(uint8_t endpoint); /** @brief Sub-GHz Cluster Suspend Zcl Messages * - * + * * * @param period Ver.: always */ @@ -21227,7 +19068,7 @@ bool emberAfSubGhzClusterSuspendZclMessagesCallback(uint8_t period); * * @param cmd Ver.: always */ -bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand *cmd); +bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand * cmd); /** @brief Key Establishment Cluster Client Attribute Changed * * Client Attribute Changed @@ -21235,8 +19076,7 @@ bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterC * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfKeyEstablishmentClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfKeyEstablishmentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Key Establishment Cluster Client Default Response * * This function is called when the client receives the default response from @@ -21246,9 +19086,7 @@ void emberAfKeyEstablishmentClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfKeyEstablishmentClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfKeyEstablishmentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Key Establishment Cluster Client Init * * Client Init @@ -21262,7 +19100,7 @@ void emberAfKeyEstablishmentClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfKeyEstablishmentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -21280,11 +19118,8 @@ void emberAfKeyEstablishmentClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfKeyEstablishmentClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfKeyEstablishmentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Key Establishment Cluster Client Pre Attribute Changed * @@ -21296,11 +19131,9 @@ void emberAfKeyEstablishmentClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfKeyEstablishmentClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfKeyEstablishmentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Key Establishment Cluster Client Tick * * Client Tick @@ -21310,35 +19143,35 @@ EmberAfStatus emberAfKeyEstablishmentClusterClientPreAttributeChangedCallback(ui void emberAfKeyEstablishmentClusterClientTickCallback(uint8_t endpoint); /** @brief Key Establishment Cluster Confirm Key Data Request * - * + * * * @param secureMessageAuthenticationCode Ver.: always */ -bool emberAfKeyEstablishmentClusterConfirmKeyDataRequestCallback(uint8_t* secureMessageAuthenticationCode); +bool emberAfKeyEstablishmentClusterConfirmKeyDataRequestCallback(uint8_t * secureMessageAuthenticationCode); /** @brief Key Establishment Cluster Confirm Key Data Response * - * + * * * @param secureMessageAuthenticationCode Ver.: always */ -bool emberAfKeyEstablishmentClusterConfirmKeyDataResponseCallback(uint8_t* secureMessageAuthenticationCode); +bool emberAfKeyEstablishmentClusterConfirmKeyDataResponseCallback(uint8_t * secureMessageAuthenticationCode); /** @brief Key Establishment Cluster Ephemeral Data Request * - * + * * * @param ephemeralData Ver.: always */ -bool emberAfKeyEstablishmentClusterEphemeralDataRequestCallback(uint8_t* ephemeralData); +bool emberAfKeyEstablishmentClusterEphemeralDataRequestCallback(uint8_t * ephemeralData); /** @brief Key Establishment Cluster Ephemeral Data Response * - * + * * * @param ephemeralData Ver.: always */ -bool emberAfKeyEstablishmentClusterEphemeralDataResponseCallback(uint8_t* ephemeralData); +bool emberAfKeyEstablishmentClusterEphemeralDataResponseCallback(uint8_t * ephemeralData); /** @brief Key Establishment Cluster Initiate Key Establishment Request * - * + * * * @param keyEstablishmentSuite Ver.: always * @param ephemeralDataGenerateTime Ver.: always @@ -21346,12 +19179,11 @@ bool emberAfKeyEstablishmentClusterEphemeralDataResponseCallback(uint8_t* epheme * @param identity Ver.: always */ bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentRequestCallback(uint16_t keyEstablishmentSuite, - uint8_t ephemeralDataGenerateTime, - uint8_t confirmKeyGenerateTime, - uint8_t* identity); + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, uint8_t * identity); /** @brief Key Establishment Cluster Initiate Key Establishment Response * - * + * * * @param requestedKeyEstablishmentSuite Ver.: always * @param ephemeralDataGenerateTime Ver.: always @@ -21359,9 +19191,8 @@ bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentRequestCallback(uint1 * @param identity Ver.: always */ bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentResponseCallback(uint16_t requestedKeyEstablishmentSuite, - uint8_t ephemeralDataGenerateTime, - uint8_t confirmKeyGenerateTime, - uint8_t* identity); + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, uint8_t * identity); /** @brief Key Establishment Cluster Server Attribute Changed * * Server Attribute Changed @@ -21369,8 +19200,7 @@ bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentResponseCallback(uint * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfKeyEstablishmentClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfKeyEstablishmentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Key Establishment Cluster Server Default Response * * This function is called when the server receives the default response from @@ -21380,9 +19210,7 @@ void emberAfKeyEstablishmentClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfKeyEstablishmentClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfKeyEstablishmentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Key Establishment Cluster Server Init * * Server Init @@ -21396,7 +19224,7 @@ void emberAfKeyEstablishmentClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfKeyEstablishmentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -21414,11 +19242,8 @@ void emberAfKeyEstablishmentClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfKeyEstablishmentClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfKeyEstablishmentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Key Establishment Cluster Server Pre Attribute Changed * @@ -21430,11 +19255,9 @@ void emberAfKeyEstablishmentClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfKeyEstablishmentClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfKeyEstablishmentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Key Establishment Cluster Server Tick * * Server Tick @@ -21444,15 +19267,14 @@ EmberAfStatus emberAfKeyEstablishmentClusterServerPreAttributeChangedCallback(ui void emberAfKeyEstablishmentClusterServerTickCallback(uint8_t endpoint); /** @brief Key Establishment Cluster Terminate Key Establishment * - * + * * * @param statusCode Ver.: always * @param waitTime Ver.: always * @param keyEstablishmentSuite Ver.: always */ -bool emberAfKeyEstablishmentClusterTerminateKeyEstablishmentCallback(uint8_t statusCode, - uint8_t waitTime, - uint16_t keyEstablishmentSuite); +bool emberAfKeyEstablishmentClusterTerminateKeyEstablishmentCallback(uint8_t statusCode, uint8_t waitTime, + uint16_t keyEstablishmentSuite); /** @brief Key Establishment Cluster Server Command Received * * This function is called by the application framework when a client-to-server @@ -21463,7 +19285,7 @@ bool emberAfKeyEstablishmentClusterTerminateKeyEstablishmentCallback(uint8_t sta * * @param cmd Ver.: always */ -bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand *cmd); +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand * cmd); /** @} END Key Establishment Cluster Callbacks */ @@ -21477,8 +19299,7 @@ bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterC * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfInformationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfInformationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Information Cluster Client Default Response * * This function is called when the client receives the default response from @@ -21488,9 +19309,7 @@ void emberAfInformationClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfInformationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfInformationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Information Cluster Client Init * * Client Init @@ -21504,11 +19323,10 @@ void emberAfInformationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfInformationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfInformationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Information Cluster Client Message Sent * @@ -21522,11 +19340,8 @@ void emberAfInformationClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfInformationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfInformationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Information Cluster Client Pre Attribute Changed * @@ -21538,11 +19353,9 @@ void emberAfInformationClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfInformationClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfInformationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Information Cluster Client Tick * * Client Tick @@ -21552,116 +19365,111 @@ EmberAfStatus emberAfInformationClusterClientPreAttributeChangedCallback(uint8_t void emberAfInformationClusterClientTickCallback(uint8_t endpoint); /** @brief Information Cluster Configure Delivery Enable * - * + * * * @param enable Ver.: always */ bool emberAfInformationClusterConfigureDeliveryEnableCallback(uint8_t enable); /** @brief Information Cluster Configure Node Description * - * + * * * @param description Ver.: always */ -bool emberAfInformationClusterConfigureNodeDescriptionCallback(uint8_t* description); +bool emberAfInformationClusterConfigureNodeDescriptionCallback(uint8_t * description); /** @brief Information Cluster Configure Push Information Timer * - * + * * * @param timer Ver.: always */ bool emberAfInformationClusterConfigurePushInformationTimerCallback(uint32_t timer); /** @brief Information Cluster Configure Set Root Id * - * + * * * @param rootId Ver.: always */ bool emberAfInformationClusterConfigureSetRootIdCallback(uint16_t rootId); /** @brief Information Cluster Delete * - * + * * * @param deletionOptions Ver.: always * @param contentIds Ver.: always */ -bool emberAfInformationClusterDeleteCallback(uint8_t deletionOptions, - uint8_t* contentIds); +bool emberAfInformationClusterDeleteCallback(uint8_t deletionOptions, uint8_t * contentIds); /** @brief Information Cluster Delete Response * - * + * * * @param notificationList Ver.: always */ -bool emberAfInformationClusterDeleteResponseCallback(uint8_t* notificationList); +bool emberAfInformationClusterDeleteResponseCallback(uint8_t * notificationList); /** @brief Information Cluster Push Information * - * + * * * @param contents Ver.: always */ -bool emberAfInformationClusterPushInformationCallback(uint8_t* contents); +bool emberAfInformationClusterPushInformationCallback(uint8_t * contents); /** @brief Information Cluster Push Information Response * - * + * * * @param notificationList Ver.: always */ -bool emberAfInformationClusterPushInformationResponseCallback(uint8_t* notificationList); +bool emberAfInformationClusterPushInformationResponseCallback(uint8_t * notificationList); /** @brief Information Cluster Request Information * - * + * * * @param inquiryId Ver.: always * @param dataTypeId Ver.: always * @param requestInformationPayload Ver.: always */ -bool emberAfInformationClusterRequestInformationCallback(uint8_t inquiryId, - uint8_t dataTypeId, - uint8_t* requestInformationPayload); +bool emberAfInformationClusterRequestInformationCallback(uint8_t inquiryId, uint8_t dataTypeId, + uint8_t * requestInformationPayload); /** @brief Information Cluster Request Information Response * - * + * * * @param number Ver.: always * @param buffer Ver.: always */ -bool emberAfInformationClusterRequestInformationResponseCallback(uint8_t number, - uint8_t* buffer); +bool emberAfInformationClusterRequestInformationResponseCallback(uint8_t number, uint8_t * buffer); /** @brief Information Cluster Request Preference Confirmation * - * + * * * @param statusFeedbackList Ver.: always */ -bool emberAfInformationClusterRequestPreferenceConfirmationCallback(uint8_t* statusFeedbackList); +bool emberAfInformationClusterRequestPreferenceConfirmationCallback(uint8_t * statusFeedbackList); /** @brief Information Cluster Request Preference Response * - * + * * * @param statusFeedback Ver.: always * @param preferenceType Ver.: always * @param preferencePayload Ver.: always */ -bool emberAfInformationClusterRequestPreferenceResponseCallback(uint8_t statusFeedback, - uint16_t preferenceType, - uint8_t* preferencePayload); +bool emberAfInformationClusterRequestPreferenceResponseCallback(uint8_t statusFeedback, uint16_t preferenceType, + uint8_t * preferencePayload); /** @brief Information Cluster Send Preference * - * + * * * @param preferenceType Ver.: always * @param preferencePayload Ver.: always */ -bool emberAfInformationClusterSendPreferenceCallback(uint16_t preferenceType, - uint8_t* preferencePayload); +bool emberAfInformationClusterSendPreferenceCallback(uint16_t preferenceType, uint8_t * preferencePayload); /** @brief Information Cluster Send Preference Response * - * + * * * @param statusFeedbackList Ver.: always */ -bool emberAfInformationClusterSendPreferenceResponseCallback(uint8_t* statusFeedbackList); +bool emberAfInformationClusterSendPreferenceResponseCallback(uint8_t * statusFeedbackList); /** @brief Information Cluster Server Attribute Changed * * Server Attribute Changed @@ -21669,8 +19477,7 @@ bool emberAfInformationClusterSendPreferenceResponseCallback(uint8_t* statusFeed * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfInformationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfInformationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Information Cluster Server Default Response * * This function is called when the server receives the default response from @@ -21680,9 +19487,7 @@ void emberAfInformationClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfInformationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfInformationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Information Cluster Server Init * * Server Init @@ -21696,11 +19501,10 @@ void emberAfInformationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfInformationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfInformationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Information Cluster Server Message Sent * @@ -21714,11 +19518,8 @@ void emberAfInformationClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfInformationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfInformationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Information Cluster Server Pre Attribute Changed * @@ -21730,14 +19531,12 @@ void emberAfInformationClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfInformationClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfInformationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Information Cluster Server Request Preference * - * + * * */ bool emberAfInformationClusterServerRequestPreferenceCallback(void); @@ -21750,22 +19549,20 @@ bool emberAfInformationClusterServerRequestPreferenceCallback(void); void emberAfInformationClusterServerTickCallback(uint8_t endpoint); /** @brief Information Cluster Update * - * + * * * @param accessControl Ver.: always * @param option Ver.: always * @param contents Ver.: always */ -bool emberAfInformationClusterUpdateCallback(uint8_t accessControl, - uint8_t option, - uint8_t* contents); +bool emberAfInformationClusterUpdateCallback(uint8_t accessControl, uint8_t option, uint8_t * contents); /** @brief Information Cluster Update Response * - * + * * * @param notificationList Ver.: always */ -bool emberAfInformationClusterUpdateResponseCallback(uint8_t* notificationList); +bool emberAfInformationClusterUpdateResponseCallback(uint8_t * notificationList); /** @} END Information Cluster Callbacks */ @@ -21779,8 +19576,7 @@ bool emberAfInformationClusterUpdateResponseCallback(uint8_t* notificationList); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDataSharingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDataSharingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Data Sharing Cluster Client Default Response * * This function is called when the client receives the default response from @@ -21790,9 +19586,7 @@ void emberAfDataSharingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDataSharingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDataSharingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Data Sharing Cluster Client Init * * Client Init @@ -21806,11 +19600,10 @@ void emberAfDataSharingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDataSharingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDataSharingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Data Sharing Cluster Client Message Sent * @@ -21824,11 +19617,8 @@ void emberAfDataSharingClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDataSharingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDataSharingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Data Sharing Cluster Client Pre Attribute Changed * @@ -21840,11 +19630,9 @@ void emberAfDataSharingClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDataSharingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDataSharingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Data Sharing Cluster Client Tick * * Client Tick @@ -21854,62 +19642,54 @@ EmberAfStatus emberAfDataSharingClusterClientPreAttributeChangedCallback(uint8_t void emberAfDataSharingClusterClientTickCallback(uint8_t endpoint); /** @brief Data Sharing Cluster File Transmission * - * + * * * @param transmitOptions Ver.: always * @param buffer Ver.: always */ -bool emberAfDataSharingClusterFileTransmissionCallback(uint8_t transmitOptions, - uint8_t* buffer); +bool emberAfDataSharingClusterFileTransmissionCallback(uint8_t transmitOptions, uint8_t * buffer); /** @brief Data Sharing Cluster Modify File Request * - * + * * * @param fileIndex Ver.: always * @param fileStartPosition Ver.: always * @param octetCount Ver.: always */ -bool emberAfDataSharingClusterModifyFileRequestCallback(uint16_t fileIndex, - uint32_t fileStartPosition, - uint32_t octetCount); +bool emberAfDataSharingClusterModifyFileRequestCallback(uint16_t fileIndex, uint32_t fileStartPosition, uint32_t octetCount); /** @brief Data Sharing Cluster Modify Record Request * - * + * * * @param fileIndex Ver.: always * @param fileStartRecord Ver.: always * @param recordCount Ver.: always */ -bool emberAfDataSharingClusterModifyRecordRequestCallback(uint16_t fileIndex, - uint16_t fileStartRecord, - uint16_t recordCount); +bool emberAfDataSharingClusterModifyRecordRequestCallback(uint16_t fileIndex, uint16_t fileStartRecord, uint16_t recordCount); /** @brief Data Sharing Cluster Read File Request * - * + * * * @param fileIndex Ver.: always * @param fileStartPositionAndRequestedOctetCount Ver.: always */ -bool emberAfDataSharingClusterReadFileRequestCallback(uint16_t fileIndex, - uint8_t* fileStartPositionAndRequestedOctetCount); +bool emberAfDataSharingClusterReadFileRequestCallback(uint16_t fileIndex, uint8_t * fileStartPositionAndRequestedOctetCount); /** @brief Data Sharing Cluster Read Record Request * - * + * * * @param fileIndex Ver.: always * @param fileStartRecordAndRequestedRecordCount Ver.: always */ -bool emberAfDataSharingClusterReadRecordRequestCallback(uint16_t fileIndex, - uint8_t* fileStartRecordAndRequestedRecordCount); +bool emberAfDataSharingClusterReadRecordRequestCallback(uint16_t fileIndex, uint8_t * fileStartRecordAndRequestedRecordCount); /** @brief Data Sharing Cluster Record Transmission * - * + * * * @param transmitOptions Ver.: always * @param buffer Ver.: always */ -bool emberAfDataSharingClusterRecordTransmissionCallback(uint8_t transmitOptions, - uint8_t* buffer); +bool emberAfDataSharingClusterRecordTransmissionCallback(uint8_t transmitOptions, uint8_t * buffer); /** @brief Data Sharing Cluster Server Attribute Changed * * Server Attribute Changed @@ -21917,8 +19697,7 @@ bool emberAfDataSharingClusterRecordTransmissionCallback(uint8_t transmitOptions * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDataSharingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDataSharingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Data Sharing Cluster Server Default Response * * This function is called when the server receives the default response from @@ -21928,9 +19707,7 @@ void emberAfDataSharingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDataSharingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDataSharingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Data Sharing Cluster Server Init * * Server Init @@ -21944,11 +19721,10 @@ void emberAfDataSharingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDataSharingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDataSharingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Data Sharing Cluster Server Message Sent * @@ -21962,11 +19738,8 @@ void emberAfDataSharingClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDataSharingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDataSharingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Data Sharing Cluster Server Pre Attribute Changed * @@ -21978,11 +19751,9 @@ void emberAfDataSharingClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDataSharingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDataSharingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Data Sharing Cluster Server Tick * * Server Tick @@ -21992,22 +19763,20 @@ EmberAfStatus emberAfDataSharingClusterServerPreAttributeChangedCallback(uint8_t void emberAfDataSharingClusterServerTickCallback(uint8_t endpoint); /** @brief Data Sharing Cluster Write File Request * - * + * * * @param writeOptions Ver.: always * @param fileSize Ver.: always */ -bool emberAfDataSharingClusterWriteFileRequestCallback(uint8_t writeOptions, - uint8_t* fileSize); +bool emberAfDataSharingClusterWriteFileRequestCallback(uint8_t writeOptions, uint8_t * fileSize); /** @brief Data Sharing Cluster Write File Response * - * + * * * @param status Ver.: always * @param fileIndex Ver.: always */ -bool emberAfDataSharingClusterWriteFileResponseCallback(uint8_t status, - uint8_t* fileIndex); +bool emberAfDataSharingClusterWriteFileResponseCallback(uint8_t status, uint8_t * fileIndex); /** @} END Data Sharing Cluster Callbacks */ @@ -22016,7 +19785,7 @@ bool emberAfDataSharingClusterWriteFileResponseCallback(uint8_t status, /** @brief Gaming Cluster Action Control * - * + * * * @param actions Ver.: always */ @@ -22028,8 +19797,7 @@ bool emberAfGamingClusterActionControlCallback(uint32_t actions); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGamingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGamingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Gaming Cluster Client Default Response * * This function is called when the client receives the default response from @@ -22039,9 +19807,7 @@ void emberAfGamingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGamingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGamingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Gaming Cluster Client Init * * Client Init @@ -22055,11 +19821,10 @@ void emberAfGamingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGamingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGamingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Gaming Cluster Client Message Sent * @@ -22073,11 +19838,8 @@ void emberAfGamingClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGamingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGamingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Gaming Cluster Client Pre Attribute Changed * @@ -22089,11 +19851,9 @@ void emberAfGamingClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGamingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGamingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Gaming Cluster Client Tick * * Client Tick @@ -22103,76 +19863,69 @@ EmberAfStatus emberAfGamingClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfGamingClusterClientTickCallback(uint8_t endpoint); /** @brief Gaming Cluster Download Game * - * + * * */ bool emberAfGamingClusterDownloadGameCallback(void); /** @brief Gaming Cluster End Game * - * + * * */ bool emberAfGamingClusterEndGameCallback(void); /** @brief Gaming Cluster Game Announcement * - * + * * * @param gameId Ver.: always * @param gameMaster Ver.: always * @param listOfGame Ver.: always */ -bool emberAfGamingClusterGameAnnouncementCallback(uint16_t gameId, - uint8_t gameMaster, - uint8_t* listOfGame); +bool emberAfGamingClusterGameAnnouncementCallback(uint16_t gameId, uint8_t gameMaster, uint8_t * listOfGame); /** @brief Gaming Cluster General Response * - * + * * * @param commandId Ver.: always * @param status Ver.: always * @param message Ver.: always */ -bool emberAfGamingClusterGeneralResponseCallback(uint8_t commandId, - uint8_t status, - uint8_t* message); +bool emberAfGamingClusterGeneralResponseCallback(uint8_t commandId, uint8_t status, uint8_t * message); /** @brief Gaming Cluster Join Game * - * + * * * @param gameId Ver.: always * @param joinAsMaster Ver.: always * @param nameOfGame Ver.: always */ -bool emberAfGamingClusterJoinGameCallback(uint16_t gameId, - uint8_t joinAsMaster, - uint8_t* nameOfGame); +bool emberAfGamingClusterJoinGameCallback(uint16_t gameId, uint8_t joinAsMaster, uint8_t * nameOfGame); /** @brief Gaming Cluster Pause Game * - * + * * */ bool emberAfGamingClusterPauseGameCallback(void); /** @brief Gaming Cluster Quit Game * - * + * * */ bool emberAfGamingClusterQuitGameCallback(void); /** @brief Gaming Cluster Resume Game * - * + * * */ bool emberAfGamingClusterResumeGameCallback(void); /** @brief Gaming Cluster Search Game * - * + * * * @param specificGame Ver.: always * @param gameId Ver.: always */ -bool emberAfGamingClusterSearchGameCallback(uint8_t specificGame, - uint16_t gameId); +bool emberAfGamingClusterSearchGameCallback(uint8_t specificGame, uint16_t gameId); /** @brief Gaming Cluster Server Attribute Changed * * Server Attribute Changed @@ -22180,8 +19933,7 @@ bool emberAfGamingClusterSearchGameCallback(uint8_t specificGame, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfGamingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfGamingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Gaming Cluster Server Default Response * * This function is called when the server receives the default response from @@ -22191,9 +19943,7 @@ void emberAfGamingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfGamingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfGamingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Gaming Cluster Server Init * * Server Init @@ -22207,11 +19957,10 @@ void emberAfGamingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfGamingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfGamingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Gaming Cluster Server Message Sent * @@ -22225,11 +19974,8 @@ void emberAfGamingClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfGamingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfGamingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Gaming Cluster Server Pre Attribute Changed * @@ -22241,11 +19987,9 @@ void emberAfGamingClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfGamingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfGamingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Gaming Cluster Server Tick * * Server Tick @@ -22255,13 +19999,13 @@ EmberAfStatus emberAfGamingClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfGamingClusterServerTickCallback(uint8_t endpoint); /** @brief Gaming Cluster Start Game * - * + * * */ bool emberAfGamingClusterStartGameCallback(void); /** @brief Gaming Cluster Start Over * - * + * * */ bool emberAfGamingClusterStartOverCallback(void); @@ -22278,8 +20022,7 @@ bool emberAfGamingClusterStartOverCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDataRateControlClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDataRateControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Data Rate Control Cluster Client Default Response * * This function is called when the client receives the default response from @@ -22289,9 +20032,7 @@ void emberAfDataRateControlClusterClientAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDataRateControlClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDataRateControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Data Rate Control Cluster Client Init * * Client Init @@ -22305,7 +20046,7 @@ void emberAfDataRateControlClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDataRateControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -22323,11 +20064,8 @@ void emberAfDataRateControlClusterClientManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDataRateControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDataRateControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Data Rate Control Cluster Client Pre Attribute Changed * @@ -22339,11 +20077,9 @@ void emberAfDataRateControlClusterClientMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDataRateControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDataRateControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Data Rate Control Cluster Client Tick * * Client Tick @@ -22353,46 +20089,41 @@ EmberAfStatus emberAfDataRateControlClusterClientPreAttributeChangedCallback(uin void emberAfDataRateControlClusterClientTickCallback(uint8_t endpoint); /** @brief Data Rate Control Cluster Data Rate Control * - * + * * * @param originatorAddress Ver.: always * @param destinationAddress Ver.: always * @param dataRate Ver.: always */ -bool emberAfDataRateControlClusterDataRateControlCallback(uint16_t originatorAddress, - uint16_t destinationAddress, - uint8_t dataRate); +bool emberAfDataRateControlClusterDataRateControlCallback(uint16_t originatorAddress, uint16_t destinationAddress, + uint8_t dataRate); /** @brief Data Rate Control Cluster Data Rate Notification * - * + * * * @param originatorAddress Ver.: always * @param destinationAddress Ver.: always * @param dataRate Ver.: always */ -bool emberAfDataRateControlClusterDataRateNotificationCallback(uint16_t originatorAddress, - uint16_t destinationAddress, - uint8_t dataRate); +bool emberAfDataRateControlClusterDataRateNotificationCallback(uint16_t originatorAddress, uint16_t destinationAddress, + uint8_t dataRate); /** @brief Data Rate Control Cluster Path Creation * - * + * * * @param originatorAddress Ver.: always * @param destinationAddress Ver.: always * @param dataRate Ver.: always */ -bool emberAfDataRateControlClusterPathCreationCallback(uint16_t originatorAddress, - uint16_t destinationAddress, - uint8_t dataRate); +bool emberAfDataRateControlClusterPathCreationCallback(uint16_t originatorAddress, uint16_t destinationAddress, uint8_t dataRate); /** @brief Data Rate Control Cluster Path Deletion * - * + * * * @param originatorAddress Ver.: always * @param destinationAddress Ver.: always */ -bool emberAfDataRateControlClusterPathDeletionCallback(uint16_t originatorAddress, - uint16_t destinationAddress); +bool emberAfDataRateControlClusterPathDeletionCallback(uint16_t originatorAddress, uint16_t destinationAddress); /** @brief Data Rate Control Cluster Server Attribute Changed * * Server Attribute Changed @@ -22400,8 +20131,7 @@ bool emberAfDataRateControlClusterPathDeletionCallback(uint16_t originatorAddres * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDataRateControlClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDataRateControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Data Rate Control Cluster Server Default Response * * This function is called when the server receives the default response from @@ -22411,9 +20141,7 @@ void emberAfDataRateControlClusterServerAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDataRateControlClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDataRateControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Data Rate Control Cluster Server Init * * Server Init @@ -22427,7 +20155,7 @@ void emberAfDataRateControlClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfDataRateControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -22445,11 +20173,8 @@ void emberAfDataRateControlClusterServerManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDataRateControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDataRateControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Data Rate Control Cluster Server Pre Attribute Changed * @@ -22461,11 +20186,9 @@ void emberAfDataRateControlClusterServerMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDataRateControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDataRateControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Data Rate Control Cluster Server Tick * * Server Tick @@ -22486,8 +20209,7 @@ void emberAfDataRateControlClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfVoiceOverZigbeeClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfVoiceOverZigbeeClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Voice over ZigBee Cluster Client Default Response * * This function is called when the client receives the default response from @@ -22497,9 +20219,7 @@ void emberAfVoiceOverZigbeeClusterClientAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfVoiceOverZigbeeClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfVoiceOverZigbeeClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Voice over ZigBee Cluster Client Init * * Client Init @@ -22513,7 +20233,7 @@ void emberAfVoiceOverZigbeeClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfVoiceOverZigbeeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -22531,11 +20251,8 @@ void emberAfVoiceOverZigbeeClusterClientManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfVoiceOverZigbeeClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfVoiceOverZigbeeClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Voice over ZigBee Cluster Client Pre Attribute Changed * @@ -22547,11 +20264,9 @@ void emberAfVoiceOverZigbeeClusterClientMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfVoiceOverZigbeeClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfVoiceOverZigbeeClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Voice over ZigBee Cluster Client Tick * * Client Tick @@ -22561,21 +20276,21 @@ EmberAfStatus emberAfVoiceOverZigbeeClusterClientPreAttributeChangedCallback(uin void emberAfVoiceOverZigbeeClusterClientTickCallback(uint8_t endpoint); /** @brief Voice over ZigBee Cluster Control * - * + * * * @param controlType Ver.: always */ bool emberAfVoiceOverZigbeeClusterControlCallback(uint8_t controlType); /** @brief Voice over ZigBee Cluster Control Response * - * + * * * @param ackNack Ver.: always */ bool emberAfVoiceOverZigbeeClusterControlResponseCallback(uint8_t ackNack); /** @brief Voice over ZigBee Cluster Establishment Request * - * + * * * @param flag Ver.: always * @param codecType Ver.: always @@ -22584,21 +20299,16 @@ bool emberAfVoiceOverZigbeeClusterControlResponseCallback(uint8_t ackNack); * @param serviceType Ver.: always * @param buffer Ver.: always */ -bool emberAfVoiceOverZigbeeClusterEstablishmentRequestCallback(uint8_t flag, - uint8_t codecType, - uint8_t sampFreq, - uint8_t codecRate, - uint8_t serviceType, - uint8_t* buffer); +bool emberAfVoiceOverZigbeeClusterEstablishmentRequestCallback(uint8_t flag, uint8_t codecType, uint8_t sampFreq, uint8_t codecRate, + uint8_t serviceType, uint8_t * buffer); /** @brief Voice over ZigBee Cluster Establishment Response * - * + * * * @param ackNack Ver.: always * @param codecType Ver.: always */ -bool emberAfVoiceOverZigbeeClusterEstablishmentResponseCallback(uint8_t ackNack, - uint8_t codecType); +bool emberAfVoiceOverZigbeeClusterEstablishmentResponseCallback(uint8_t ackNack, uint8_t codecType); /** @brief Voice over ZigBee Cluster Server Attribute Changed * * Server Attribute Changed @@ -22606,8 +20316,7 @@ bool emberAfVoiceOverZigbeeClusterEstablishmentResponseCallback(uint8_t ackNack, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfVoiceOverZigbeeClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfVoiceOverZigbeeClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Voice over ZigBee Cluster Server Default Response * * This function is called when the server receives the default response from @@ -22617,9 +20326,7 @@ void emberAfVoiceOverZigbeeClusterServerAttributeChangedCallback(uint8_t endpoin * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfVoiceOverZigbeeClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfVoiceOverZigbeeClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Voice over ZigBee Cluster Server Init * * Server Init @@ -22633,7 +20340,7 @@ void emberAfVoiceOverZigbeeClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfVoiceOverZigbeeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -22651,11 +20358,8 @@ void emberAfVoiceOverZigbeeClusterServerManufacturerSpecificAttributeChangedCall * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfVoiceOverZigbeeClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfVoiceOverZigbeeClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Voice over ZigBee Cluster Server Pre Attribute Changed * @@ -22667,11 +20371,9 @@ void emberAfVoiceOverZigbeeClusterServerMessageSentCallback(EmberOutgoingMessage * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfVoiceOverZigbeeClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfVoiceOverZigbeeClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Voice over ZigBee Cluster Server Tick * * Server Tick @@ -22681,26 +20383,25 @@ EmberAfStatus emberAfVoiceOverZigbeeClusterServerPreAttributeChangedCallback(uin void emberAfVoiceOverZigbeeClusterServerTickCallback(uint8_t endpoint); /** @brief Voice over ZigBee Cluster Voice Transmission * - * + * * * @param voiceData Ver.: always */ -bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCallback(uint8_t* voiceData); +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCallback(uint8_t * voiceData); /** @brief Voice over ZigBee Cluster Voice Transmission Completion * - * + * * */ bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCompletionCallback(void); /** @brief Voice over ZigBee Cluster Voice Transmission Response * - * + * * * @param sequenceNumber Ver.: always * @param errorFlag Ver.: always */ -bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequenceNumber, - uint8_t errorFlag); +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequenceNumber, uint8_t errorFlag); /** @} END Voice over ZigBee Cluster Callbacks */ @@ -22709,7 +20410,7 @@ bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequ /** @brief Chatting Cluster Chat Message * - * + * * * @param destinationUid Ver.: always * @param sourceUid Ver.: always @@ -22717,11 +20418,8 @@ bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequ * @param nickname Ver.: always * @param message Ver.: always */ -bool emberAfChattingClusterChatMessageCallback(uint16_t destinationUid, - uint16_t sourceUid, - uint16_t cid, - uint8_t* nickname, - uint8_t* message); +bool emberAfChattingClusterChatMessageCallback(uint16_t destinationUid, uint16_t sourceUid, uint16_t cid, uint8_t * nickname, + uint8_t * message); /** @brief Chatting Cluster Client Attribute Changed * * Client Attribute Changed @@ -22729,8 +20427,7 @@ bool emberAfChattingClusterChatMessageCallback(uint16_t destinationUid, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfChattingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfChattingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Chatting Cluster Client Default Response * * This function is called when the client receives the default response from @@ -22740,9 +20437,7 @@ void emberAfChattingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChattingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfChattingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chatting Cluster Client Init * * Client Init @@ -22756,11 +20451,10 @@ void emberAfChattingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChattingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfChattingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chatting Cluster Client Message Sent * @@ -22774,11 +20468,8 @@ void emberAfChattingClusterClientManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfChattingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfChattingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Chatting Cluster Client Pre Attribute Changed * @@ -22790,11 +20481,9 @@ void emberAfChattingClusterClientMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfChattingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfChattingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Chatting Cluster Client Tick * * Client Tick @@ -22804,72 +20493,63 @@ EmberAfStatus emberAfChattingClusterClientPreAttributeChangedCallback(uint8_t en void emberAfChattingClusterClientTickCallback(uint8_t endpoint); /** @brief Chatting Cluster Get Node Information Request * - * + * * * @param cid Ver.: always * @param uid Ver.: always */ -bool emberAfChattingClusterGetNodeInformationRequestCallback(uint16_t cid, - uint16_t uid); +bool emberAfChattingClusterGetNodeInformationRequestCallback(uint16_t cid, uint16_t uid); /** @brief Chatting Cluster Get Node Information Response * - * + * * * @param status Ver.: always * @param cid Ver.: always * @param uid Ver.: always * @param addressEndpointAndNickname Ver.: always */ -bool emberAfChattingClusterGetNodeInformationResponseCallback(uint8_t status, - uint16_t cid, - uint16_t uid, - uint8_t* addressEndpointAndNickname); +bool emberAfChattingClusterGetNodeInformationResponseCallback(uint8_t status, uint16_t cid, uint16_t uid, + uint8_t * addressEndpointAndNickname); /** @brief Chatting Cluster Join Chat Request * - * + * * * @param uid Ver.: always * @param nickname Ver.: always * @param cid Ver.: always */ -bool emberAfChattingClusterJoinChatRequestCallback(uint16_t uid, - uint8_t* nickname, - uint16_t cid); +bool emberAfChattingClusterJoinChatRequestCallback(uint16_t uid, uint8_t * nickname, uint16_t cid); /** @brief Chatting Cluster Join Chat Response * - * + * * * @param status Ver.: always * @param cid Ver.: always * @param chatParticipantList Ver.: always */ -bool emberAfChattingClusterJoinChatResponseCallback(uint8_t status, - uint16_t cid, - uint8_t* chatParticipantList); +bool emberAfChattingClusterJoinChatResponseCallback(uint8_t status, uint16_t cid, uint8_t * chatParticipantList); /** @brief Chatting Cluster Leave Chat Request * - * + * * * @param cid Ver.: always * @param uid Ver.: always */ -bool emberAfChattingClusterLeaveChatRequestCallback(uint16_t cid, - uint16_t uid); +bool emberAfChattingClusterLeaveChatRequestCallback(uint16_t cid, uint16_t uid); /** @brief Chatting Cluster Search Chat Request * - * + * * */ bool emberAfChattingClusterSearchChatRequestCallback(void); /** @brief Chatting Cluster Search Chat Response * - * + * * * @param options Ver.: always * @param chatRoomList Ver.: always */ -bool emberAfChattingClusterSearchChatResponseCallback(uint8_t options, - uint8_t* chatRoomList); +bool emberAfChattingClusterSearchChatResponseCallback(uint8_t options, uint8_t * chatRoomList); /** @brief Chatting Cluster Server Attribute Changed * * Server Attribute Changed @@ -22877,8 +20557,7 @@ bool emberAfChattingClusterSearchChatResponseCallback(uint8_t options, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfChattingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfChattingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Chatting Cluster Server Default Response * * This function is called when the server receives the default response from @@ -22888,9 +20567,7 @@ void emberAfChattingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfChattingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfChattingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Chatting Cluster Server Init * * Server Init @@ -22904,11 +20581,10 @@ void emberAfChattingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfChattingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfChattingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Chatting Cluster Server Message Sent * @@ -22922,11 +20598,8 @@ void emberAfChattingClusterServerManufacturerSpecificAttributeChangedCallback(ui * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfChattingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfChattingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Chatting Cluster Server Pre Attribute Changed * @@ -22938,11 +20611,9 @@ void emberAfChattingClusterServerMessageSentCallback(EmberOutgoingMessageType ty * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfChattingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfChattingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Chatting Cluster Server Tick * * Server Tick @@ -22952,84 +20623,72 @@ EmberAfStatus emberAfChattingClusterServerPreAttributeChangedCallback(uint8_t en void emberAfChattingClusterServerTickCallback(uint8_t endpoint); /** @brief Chatting Cluster Start Chat Request * - * + * * * @param name Ver.: always * @param uid Ver.: always * @param nickname Ver.: always */ -bool emberAfChattingClusterStartChatRequestCallback(uint8_t* name, - uint16_t uid, - uint8_t* nickname); +bool emberAfChattingClusterStartChatRequestCallback(uint8_t * name, uint16_t uid, uint8_t * nickname); /** @brief Chatting Cluster Start Chat Response * - * + * * * @param status Ver.: always * @param cid Ver.: always */ -bool emberAfChattingClusterStartChatResponseCallback(uint8_t status, - uint16_t cid); +bool emberAfChattingClusterStartChatResponseCallback(uint8_t status, uint16_t cid); /** @brief Chatting Cluster Switch Chairman Confirm * - * + * * * @param cid Ver.: always * @param nodeInformationList Ver.: always */ -bool emberAfChattingClusterSwitchChairmanConfirmCallback(uint16_t cid, - uint8_t* nodeInformationList); +bool emberAfChattingClusterSwitchChairmanConfirmCallback(uint16_t cid, uint8_t * nodeInformationList); /** @brief Chatting Cluster Switch Chairman Notification * - * + * * * @param cid Ver.: always * @param uid Ver.: always * @param address Ver.: always * @param endpoint Ver.: always */ -bool emberAfChattingClusterSwitchChairmanNotificationCallback(uint16_t cid, - uint16_t uid, - uint16_t address, - uint8_t endpoint); +bool emberAfChattingClusterSwitchChairmanNotificationCallback(uint16_t cid, uint16_t uid, uint16_t address, uint8_t endpoint); /** @brief Chatting Cluster Switch Chairman Request * - * + * * * @param cid Ver.: always */ bool emberAfChattingClusterSwitchChairmanRequestCallback(uint16_t cid); /** @brief Chatting Cluster Switch Chairman Response * - * + * * * @param cid Ver.: always * @param uid Ver.: always */ -bool emberAfChattingClusterSwitchChairmanResponseCallback(uint16_t cid, - uint16_t uid); +bool emberAfChattingClusterSwitchChairmanResponseCallback(uint16_t cid, uint16_t uid); /** @brief Chatting Cluster User Joined * - * + * * * @param cid Ver.: always * @param uid Ver.: always * @param nickname Ver.: always */ -bool emberAfChattingClusterUserJoinedCallback(uint16_t cid, - uint16_t uid, - uint8_t* nickname); +bool emberAfChattingClusterUserJoinedCallback(uint16_t cid, uint16_t uid, uint8_t * nickname); /** @brief Chatting Cluster User Left * - * + * * * @param cid Ver.: always * @param uid Ver.: always * @param nickname Ver.: always */ -bool emberAfChattingClusterUserLeftCallback(uint16_t cid, - uint16_t uid, - uint8_t* nickname); +bool emberAfChattingClusterUserLeftCallback(uint16_t cid, uint16_t uid, uint8_t * nickname); /** @} END Chatting Cluster Callbacks */ @@ -23038,20 +20697,17 @@ bool emberAfChattingClusterUserLeftCallback(uint16_t cid, /** @brief Payment Cluster Accept Payment * - * + * * * @param userId Ver.: always * @param userType Ver.: always * @param serviceId Ver.: always * @param goodId Ver.: always */ -bool emberAfPaymentClusterAcceptPaymentCallback(uint8_t* userId, - uint16_t userType, - uint16_t serviceId, - uint8_t* goodId); +bool emberAfPaymentClusterAcceptPaymentCallback(uint8_t * userId, uint16_t userType, uint16_t serviceId, uint8_t * goodId); /** @brief Payment Cluster Buy Confirm * - * + * * * @param serialNumber Ver.: always * @param currency Ver.: always @@ -23061,26 +20717,18 @@ bool emberAfPaymentClusterAcceptPaymentCallback(uint8_t* userId, * @param transId Ver.: always * @param transStatus Ver.: always */ -bool emberAfPaymentClusterBuyConfirmCallback(uint8_t* serialNumber, - uint32_t currency, - uint8_t priceTrailingDigit, - uint32_t price, - uint8_t* timestamp, - uint16_t transId, - uint8_t transStatus); +bool emberAfPaymentClusterBuyConfirmCallback(uint8_t * serialNumber, uint32_t currency, uint8_t priceTrailingDigit, uint32_t price, + uint8_t * timestamp, uint16_t transId, uint8_t transStatus); /** @brief Payment Cluster Buy Request * - * + * * * @param userId Ver.: always * @param userType Ver.: always * @param serviceId Ver.: always * @param goodId Ver.: always */ -bool emberAfPaymentClusterBuyRequestCallback(uint8_t* userId, - uint16_t userType, - uint16_t serviceId, - uint8_t* goodId); +bool emberAfPaymentClusterBuyRequestCallback(uint8_t * userId, uint16_t userType, uint16_t serviceId, uint8_t * goodId); /** @brief Payment Cluster Client Attribute Changed * * Client Attribute Changed @@ -23088,8 +20736,7 @@ bool emberAfPaymentClusterBuyRequestCallback(uint8_t* userId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPaymentClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPaymentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Payment Cluster Client Default Response * * This function is called when the client receives the default response from @@ -23099,9 +20746,7 @@ void emberAfPaymentClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPaymentClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPaymentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Payment Cluster Client Init * * Client Init @@ -23115,11 +20760,10 @@ void emberAfPaymentClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Payment Cluster Client Message Sent * @@ -23133,11 +20777,8 @@ void emberAfPaymentClusterClientManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Payment Cluster Client Pre Attribute Changed * @@ -23149,11 +20790,9 @@ void emberAfPaymentClusterClientMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Payment Cluster Client Tick * * Client Tick @@ -23163,18 +20802,16 @@ EmberAfStatus emberAfPaymentClusterClientPreAttributeChangedCallback(uint8_t end void emberAfPaymentClusterClientTickCallback(uint8_t endpoint); /** @brief Payment Cluster Payment Confirm * - * + * * * @param serialNumber Ver.: always * @param transId Ver.: always * @param transStatus Ver.: always */ -bool emberAfPaymentClusterPaymentConfirmCallback(uint8_t* serialNumber, - uint16_t transId, - uint8_t transStatus); +bool emberAfPaymentClusterPaymentConfirmCallback(uint8_t * serialNumber, uint16_t transId, uint8_t transStatus); /** @brief Payment Cluster Receipt Delivery * - * + * * * @param serialNumber Ver.: always * @param currency Ver.: always @@ -23182,11 +20819,8 @@ bool emberAfPaymentClusterPaymentConfirmCallback(uint8_t* serialNumber, * @param price Ver.: always * @param timestamp Ver.: always */ -bool emberAfPaymentClusterReceiptDeliveryCallback(uint8_t* serialNumber, - uint32_t currency, - uint8_t priceTrailingDigit, - uint32_t price, - uint8_t* timestamp); +bool emberAfPaymentClusterReceiptDeliveryCallback(uint8_t * serialNumber, uint32_t currency, uint8_t priceTrailingDigit, + uint32_t price, uint8_t * timestamp); /** @brief Payment Cluster Server Attribute Changed * * Server Attribute Changed @@ -23194,8 +20828,7 @@ bool emberAfPaymentClusterReceiptDeliveryCallback(uint8_t* serialNumber, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfPaymentClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfPaymentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Payment Cluster Server Default Response * * This function is called when the server receives the default response from @@ -23205,9 +20838,7 @@ void emberAfPaymentClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfPaymentClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfPaymentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Payment Cluster Server Init * * Server Init @@ -23221,11 +20852,10 @@ void emberAfPaymentClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfPaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfPaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Payment Cluster Server Message Sent * @@ -23239,11 +20869,8 @@ void emberAfPaymentClusterServerManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfPaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfPaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Payment Cluster Server Pre Attribute Changed * @@ -23255,11 +20882,9 @@ void emberAfPaymentClusterServerMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfPaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfPaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Payment Cluster Server Tick * * Server Tick @@ -23269,13 +20894,12 @@ EmberAfStatus emberAfPaymentClusterServerPreAttributeChangedCallback(uint8_t end void emberAfPaymentClusterServerTickCallback(uint8_t endpoint); /** @brief Payment Cluster Transaction End * - * + * * * @param serialNumber Ver.: always * @param status Ver.: always */ -bool emberAfPaymentClusterTransactionEndCallback(uint8_t* serialNumber, - uint8_t status); +bool emberAfPaymentClusterTransactionEndCallback(uint8_t * serialNumber, uint8_t status); /** @} END Payment Cluster Callbacks */ @@ -23284,24 +20908,21 @@ bool emberAfPaymentClusterTransactionEndCallback(uint8_t* serialNumber, /** @brief Billing Cluster Bill Status Notification * - * + * * * @param userId Ver.: always * @param status Ver.: always */ -bool emberAfBillingClusterBillStatusNotificationCallback(uint8_t* userId, - uint8_t status); +bool emberAfBillingClusterBillStatusNotificationCallback(uint8_t * userId, uint8_t status); /** @brief Billing Cluster Check Bill Status * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterCheckBillStatusCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterCheckBillStatusCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @brief Billing Cluster Client Attribute Changed * * Client Attribute Changed @@ -23309,8 +20930,7 @@ bool emberAfBillingClusterCheckBillStatusCallback(uint8_t* userId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBillingClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBillingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Billing Cluster Client Default Response * * This function is called when the client receives the default response from @@ -23320,9 +20940,7 @@ void emberAfBillingClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBillingClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBillingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Billing Cluster Client Init * * Client Init @@ -23336,11 +20954,10 @@ void emberAfBillingClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBillingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfBillingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Billing Cluster Client Message Sent * @@ -23354,11 +20971,8 @@ void emberAfBillingClusterClientManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBillingClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBillingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Billing Cluster Client Pre Attribute Changed * @@ -23370,11 +20984,9 @@ void emberAfBillingClusterClientMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBillingClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBillingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Billing Cluster Client Tick * * Client Tick @@ -23384,7 +20996,7 @@ EmberAfStatus emberAfBillingClusterClientPreAttributeChangedCallback(uint8_t end void emberAfBillingClusterClientTickCallback(uint8_t endpoint); /** @brief Billing Cluster Send Bill Record * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always @@ -23392,11 +21004,8 @@ void emberAfBillingClusterClientTickCallback(uint8_t endpoint); * @param timestamp Ver.: always * @param duration Ver.: always */ -bool emberAfBillingClusterSendBillRecordCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId, - uint8_t* timestamp, - uint16_t duration); +bool emberAfBillingClusterSendBillRecordCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId, + uint8_t * timestamp, uint16_t duration); /** @brief Billing Cluster Server Attribute Changed * * Server Attribute Changed @@ -23404,8 +21013,7 @@ bool emberAfBillingClusterSendBillRecordCallback(uint8_t* userId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfBillingClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfBillingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Billing Cluster Server Default Response * * This function is called when the server receives the default response from @@ -23415,9 +21023,7 @@ void emberAfBillingClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfBillingClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfBillingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Billing Cluster Server Init * * Server Init @@ -23431,11 +21037,10 @@ void emberAfBillingClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfBillingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfBillingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Billing Cluster Server Message Sent * @@ -23449,11 +21054,8 @@ void emberAfBillingClusterServerManufacturerSpecificAttributeChangedCallback(uin * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfBillingClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfBillingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Billing Cluster Server Pre Attribute Changed * @@ -23465,11 +21067,9 @@ void emberAfBillingClusterServerMessageSentCallback(EmberOutgoingMessageType typ * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfBillingClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfBillingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Billing Cluster Server Tick * * Server Tick @@ -23479,59 +21079,49 @@ EmberAfStatus emberAfBillingClusterServerPreAttributeChangedCallback(uint8_t end void emberAfBillingClusterServerTickCallback(uint8_t endpoint); /** @brief Billing Cluster Session Keep Alive * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterSessionKeepAliveCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterSessionKeepAliveCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @brief Billing Cluster Start Billing Session * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterStartBillingSessionCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterStartBillingSessionCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @brief Billing Cluster Stop Billing Session * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterStopBillingSessionCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterStopBillingSessionCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @brief Billing Cluster Subscribe * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterSubscribeCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterSubscribeCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @brief Billing Cluster Unsubscribe * - * + * * * @param userId Ver.: always * @param serviceId Ver.: always * @param serviceProviderId Ver.: always */ -bool emberAfBillingClusterUnsubscribeCallback(uint8_t* userId, - uint16_t serviceId, - uint16_t serviceProviderId); +bool emberAfBillingClusterUnsubscribeCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); /** @} END Billing Cluster Callbacks */ @@ -23545,8 +21135,7 @@ bool emberAfBillingClusterUnsubscribeCallback(uint8_t* userId, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Identification Cluster Client Default Response * * This function is called when the client receives the default response from @@ -23556,9 +21145,7 @@ void emberAfApplianceIdentificationClusterClientAttributeChangedCallback(uint8_t * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Identification Cluster Client Init * * Client Init @@ -23572,7 +21159,7 @@ void emberAfApplianceIdentificationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -23590,11 +21177,8 @@ void emberAfApplianceIdentificationClusterClientManufacturerSpecificAttributeCha * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Identification Cluster Client Pre Attribute Changed * @@ -23609,8 +21193,7 @@ void emberAfApplianceIdentificationClusterClientMessageSentCallback(EmberOutgoin EmberAfStatus emberAfApplianceIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Appliance Identification Cluster Client Tick * * Client Tick @@ -23625,8 +21208,7 @@ void emberAfApplianceIdentificationClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Identification Cluster Server Default Response * * This function is called when the server receives the default response from @@ -23636,9 +21218,7 @@ void emberAfApplianceIdentificationClusterServerAttributeChangedCallback(uint8_t * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Identification Cluster Server Init * * Server Init @@ -23652,7 +21232,7 @@ void emberAfApplianceIdentificationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -23670,11 +21250,8 @@ void emberAfApplianceIdentificationClusterServerManufacturerSpecificAttributeCha * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Identification Cluster Server Pre Attribute Changed * @@ -23689,8 +21266,7 @@ void emberAfApplianceIdentificationClusterServerMessageSentCallback(EmberOutgoin EmberAfStatus emberAfApplianceIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Appliance Identification Cluster Server Tick * * Server Tick @@ -23711,8 +21287,7 @@ void emberAfApplianceIdentificationClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMeterIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMeterIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Meter Identification Cluster Client Default Response * * This function is called when the client receives the default response from @@ -23722,9 +21297,7 @@ void emberAfMeterIdentificationClusterClientAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMeterIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMeterIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Meter Identification Cluster Client Init * * Client Init @@ -23738,7 +21311,7 @@ void emberAfMeterIdentificationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfMeterIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -23756,11 +21329,8 @@ void emberAfMeterIdentificationClusterClientManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMeterIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMeterIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Meter Identification Cluster Client Pre Attribute Changed * @@ -23772,11 +21342,9 @@ void emberAfMeterIdentificationClusterClientMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMeterIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMeterIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Meter Identification Cluster Client Tick * * Client Tick @@ -23791,8 +21359,7 @@ void emberAfMeterIdentificationClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMeterIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMeterIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Meter Identification Cluster Server Default Response * * This function is called when the server receives the default response from @@ -23802,9 +21369,7 @@ void emberAfMeterIdentificationClusterServerAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMeterIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMeterIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Meter Identification Cluster Server Init * * Server Init @@ -23818,7 +21383,7 @@ void emberAfMeterIdentificationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfMeterIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -23836,11 +21401,8 @@ void emberAfMeterIdentificationClusterServerManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMeterIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMeterIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Meter Identification Cluster Server Pre Attribute Changed * @@ -23852,11 +21414,9 @@ void emberAfMeterIdentificationClusterServerMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMeterIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMeterIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Meter Identification Cluster Server Tick * * Server Tick @@ -23872,13 +21432,12 @@ void emberAfMeterIdentificationClusterServerTickCallback(uint8_t endpoint); /** @brief Appliance Events and Alert Cluster Alerts Notification * - * + * * * @param alertsCount Ver.: always * @param alertStructures Ver.: always */ -bool emberAfApplianceEventsAndAlertClusterAlertsNotificationCallback(uint8_t alertsCount, - uint8_t* alertStructures); +bool emberAfApplianceEventsAndAlertClusterAlertsNotificationCallback(uint8_t alertsCount, uint8_t * alertStructures); /** @brief Appliance Events and Alert Cluster Client Attribute Changed * * Client Attribute Changed @@ -23886,8 +21445,7 @@ bool emberAfApplianceEventsAndAlertClusterAlertsNotificationCallback(uint8_t ale * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceEventsAndAlertClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceEventsAndAlertClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Events and Alert Cluster Client Default Response * * This function is called when the client receives the default response from @@ -23897,9 +21455,7 @@ void emberAfApplianceEventsAndAlertClusterClientAttributeChangedCallback(uint8_t * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceEventsAndAlertClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceEventsAndAlertClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Events and Alert Cluster Client Init * * Client Init @@ -23913,7 +21469,7 @@ void emberAfApplianceEventsAndAlertClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceEventsAndAlertClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -23931,11 +21487,8 @@ void emberAfApplianceEventsAndAlertClusterClientManufacturerSpecificAttributeCha * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceEventsAndAlertClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceEventsAndAlertClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Events and Alert Cluster Client Pre Attribute Changed * @@ -23950,8 +21503,7 @@ void emberAfApplianceEventsAndAlertClusterClientMessageSentCallback(EmberOutgoin EmberAfStatus emberAfApplianceEventsAndAlertClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Appliance Events and Alert Cluster Client Tick * * Client Tick @@ -23961,28 +21513,26 @@ EmberAfStatus emberAfApplianceEventsAndAlertClusterClientPreAttributeChangedCall void emberAfApplianceEventsAndAlertClusterClientTickCallback(uint8_t endpoint); /** @brief Appliance Events and Alert Cluster Events Notification * - * + * * * @param eventHeader Ver.: always * @param eventId Ver.: always */ -bool emberAfApplianceEventsAndAlertClusterEventsNotificationCallback(uint8_t eventHeader, - uint8_t eventId); +bool emberAfApplianceEventsAndAlertClusterEventsNotificationCallback(uint8_t eventHeader, uint8_t eventId); /** @brief Appliance Events and Alert Cluster Get Alerts * - * + * * */ bool emberAfApplianceEventsAndAlertClusterGetAlertsCallback(void); /** @brief Appliance Events and Alert Cluster Get Alerts Response * - * + * * * @param alertsCount Ver.: always * @param alertStructures Ver.: always */ -bool emberAfApplianceEventsAndAlertClusterGetAlertsResponseCallback(uint8_t alertsCount, - uint8_t* alertStructures); +bool emberAfApplianceEventsAndAlertClusterGetAlertsResponseCallback(uint8_t alertsCount, uint8_t * alertStructures); /** @brief Appliance Events and Alert Cluster Server Attribute Changed * * Server Attribute Changed @@ -23990,8 +21540,7 @@ bool emberAfApplianceEventsAndAlertClusterGetAlertsResponseCallback(uint8_t aler * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceEventsAndAlertClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceEventsAndAlertClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Events and Alert Cluster Server Default Response * * This function is called when the server receives the default response from @@ -24001,9 +21550,7 @@ void emberAfApplianceEventsAndAlertClusterServerAttributeChangedCallback(uint8_t * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceEventsAndAlertClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceEventsAndAlertClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Events and Alert Cluster Server Init * * Server Init @@ -24017,7 +21564,7 @@ void emberAfApplianceEventsAndAlertClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceEventsAndAlertClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24035,11 +21582,8 @@ void emberAfApplianceEventsAndAlertClusterServerManufacturerSpecificAttributeCha * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceEventsAndAlertClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceEventsAndAlertClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Events and Alert Cluster Server Pre Attribute Changed * @@ -24054,8 +21598,7 @@ void emberAfApplianceEventsAndAlertClusterServerMessageSentCallback(EmberOutgoin EmberAfStatus emberAfApplianceEventsAndAlertClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); + uint8_t size, uint8_t * value); /** @brief Appliance Events and Alert Cluster Server Tick * * Server Tick @@ -24076,8 +21619,7 @@ void emberAfApplianceEventsAndAlertClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceStatisticsClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceStatisticsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Statistics Cluster Client Default Response * * This function is called when the client receives the default response from @@ -24087,9 +21629,7 @@ void emberAfApplianceStatisticsClusterClientAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceStatisticsClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceStatisticsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Statistics Cluster Client Init * * Client Init @@ -24103,7 +21643,7 @@ void emberAfApplianceStatisticsClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceStatisticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24121,11 +21661,8 @@ void emberAfApplianceStatisticsClusterClientManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceStatisticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceStatisticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Statistics Cluster Client Pre Attribute Changed * @@ -24137,11 +21674,9 @@ void emberAfApplianceStatisticsClusterClientMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfApplianceStatisticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfApplianceStatisticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Appliance Statistics Cluster Client Tick * * Client Tick @@ -24151,52 +21686,47 @@ EmberAfStatus emberAfApplianceStatisticsClusterClientPreAttributeChangedCallback void emberAfApplianceStatisticsClusterClientTickCallback(uint8_t endpoint); /** @brief Appliance Statistics Cluster Log Notification * - * + * * * @param timeStamp Ver.: always * @param logId Ver.: always * @param logLength Ver.: always * @param logPayload Ver.: always */ -bool emberAfApplianceStatisticsClusterLogNotificationCallback(uint32_t timeStamp, - uint32_t logId, - uint32_t logLength, - uint8_t* logPayload); +bool emberAfApplianceStatisticsClusterLogNotificationCallback(uint32_t timeStamp, uint32_t logId, uint32_t logLength, + uint8_t * logPayload); /** @brief Appliance Statistics Cluster Log Queue Request * - * + * * */ bool emberAfApplianceStatisticsClusterLogQueueRequestCallback(void); /** @brief Appliance Statistics Cluster Log Queue Response * - * + * * * @param logQueueSize Ver.: always * @param logIds Ver.: always */ -bool emberAfApplianceStatisticsClusterLogQueueResponseCallback(uint8_t logQueueSize, - uint8_t* logIds); +bool emberAfApplianceStatisticsClusterLogQueueResponseCallback(uint8_t logQueueSize, uint8_t * logIds); /** @brief Appliance Statistics Cluster Log Request * - * + * * * @param logId Ver.: always */ bool emberAfApplianceStatisticsClusterLogRequestCallback(uint32_t logId); /** @brief Appliance Statistics Cluster Log Response * - * + * * * @param timeStamp Ver.: always * @param logId Ver.: always * @param logLength Ver.: always * @param logPayload Ver.: always */ -bool emberAfApplianceStatisticsClusterLogResponseCallback(uint32_t timeStamp, - uint32_t logId, - uint32_t logLength, - uint8_t* logPayload); +bool emberAfApplianceStatisticsClusterLogResponseCallback(uint32_t timeStamp, uint32_t logId, uint32_t logLength, + uint8_t * logPayload); /** @brief Appliance Statistics Cluster Server Attribute Changed * * Server Attribute Changed @@ -24204,8 +21734,7 @@ bool emberAfApplianceStatisticsClusterLogResponseCallback(uint32_t timeStamp, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfApplianceStatisticsClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfApplianceStatisticsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Appliance Statistics Cluster Server Default Response * * This function is called when the server receives the default response from @@ -24215,9 +21744,7 @@ void emberAfApplianceStatisticsClusterServerAttributeChangedCallback(uint8_t end * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfApplianceStatisticsClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfApplianceStatisticsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Appliance Statistics Cluster Server Init * * Server Init @@ -24231,7 +21758,7 @@ void emberAfApplianceStatisticsClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfApplianceStatisticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24249,11 +21776,8 @@ void emberAfApplianceStatisticsClusterServerManufacturerSpecificAttributeChanged * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfApplianceStatisticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfApplianceStatisticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Appliance Statistics Cluster Server Pre Attribute Changed * @@ -24265,11 +21789,9 @@ void emberAfApplianceStatisticsClusterServerMessageSentCallback(EmberOutgoingMes * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfApplianceStatisticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfApplianceStatisticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Appliance Statistics Cluster Server Tick * * Server Tick @@ -24279,13 +21801,12 @@ EmberAfStatus emberAfApplianceStatisticsClusterServerPreAttributeChangedCallback void emberAfApplianceStatisticsClusterServerTickCallback(uint8_t endpoint); /** @brief Appliance Statistics Cluster Statistics Available * - * + * * * @param logQueueSize Ver.: always * @param logIds Ver.: always */ -bool emberAfApplianceStatisticsClusterStatisticsAvailableCallback(uint8_t logQueueSize, - uint8_t* logIds); +bool emberAfApplianceStatisticsClusterStatisticsAvailableCallback(uint8_t logQueueSize, uint8_t * logIds); /** @} END Appliance Statistics Cluster Callbacks */ @@ -24299,8 +21820,7 @@ bool emberAfApplianceStatisticsClusterStatisticsAvailableCallback(uint8_t logQue * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfElectricalMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfElectricalMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Electrical Measurement Cluster Client Default Response * * This function is called when the client receives the default response from @@ -24310,9 +21830,7 @@ void emberAfElectricalMeasurementClusterClientAttributeChangedCallback(uint8_t e * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfElectricalMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfElectricalMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Electrical Measurement Cluster Client Init * * Client Init @@ -24326,7 +21844,7 @@ void emberAfElectricalMeasurementClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfElectricalMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24344,11 +21862,8 @@ void emberAfElectricalMeasurementClusterClientManufacturerSpecificAttributeChang * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfElectricalMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfElectricalMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Electrical Measurement Cluster Client Pre Attribute Changed * @@ -24360,11 +21875,9 @@ void emberAfElectricalMeasurementClusterClientMessageSentCallback(EmberOutgoingM * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfElectricalMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfElectricalMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Electrical Measurement Cluster Client Tick * * Client Tick @@ -24374,18 +21887,17 @@ EmberAfStatus emberAfElectricalMeasurementClusterClientPreAttributeChangedCallba void emberAfElectricalMeasurementClusterClientTickCallback(uint8_t endpoint); /** @brief Electrical Measurement Cluster Get Measurement Profile Command * - * + * * * @param attributeId Ver.: always * @param startTime Ver.: always * @param numberOfIntervals Ver.: always */ -bool emberAfElectricalMeasurementClusterGetMeasurementProfileCommandCallback(uint16_t attributeId, - uint32_t startTime, - uint8_t numberOfIntervals); +bool emberAfElectricalMeasurementClusterGetMeasurementProfileCommandCallback(uint16_t attributeId, uint32_t startTime, + uint8_t numberOfIntervals); /** @brief Electrical Measurement Cluster Get Measurement Profile Response Command * - * + * * * @param startTime Ver.: always * @param status Ver.: always @@ -24394,31 +21906,28 @@ bool emberAfElectricalMeasurementClusterGetMeasurementProfileCommandCallback(uin * @param attributeId Ver.: always * @param intervals Ver.: always */ -bool emberAfElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(uint32_t startTime, - uint8_t status, - uint8_t profileIntervalPeriod, - uint8_t numberOfIntervalsDelivered, - uint16_t attributeId, - uint8_t* intervals); +bool emberAfElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(uint32_t startTime, uint8_t status, + uint8_t profileIntervalPeriod, + uint8_t numberOfIntervalsDelivered, + uint16_t attributeId, uint8_t * intervals); /** @brief Electrical Measurement Cluster Get Profile Info Command * - * + * * */ bool emberAfElectricalMeasurementClusterGetProfileInfoCommandCallback(void); /** @brief Electrical Measurement Cluster Get Profile Info Response Command * - * + * * * @param profileCount Ver.: always * @param profileIntervalPeriod Ver.: always * @param maxNumberOfIntervals Ver.: always * @param listOfAttributes Ver.: always */ -bool emberAfElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(uint8_t profileCount, - uint8_t profileIntervalPeriod, - uint8_t maxNumberOfIntervals, - uint8_t* listOfAttributes); +bool emberAfElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(uint8_t profileCount, uint8_t profileIntervalPeriod, + uint8_t maxNumberOfIntervals, + uint8_t * listOfAttributes); /** @brief Electrical Measurement Cluster Server Attribute Changed * * Server Attribute Changed @@ -24426,8 +21935,7 @@ bool emberAfElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(ui * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfElectricalMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfElectricalMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Electrical Measurement Cluster Server Default Response * * This function is called when the server receives the default response from @@ -24437,9 +21945,7 @@ void emberAfElectricalMeasurementClusterServerAttributeChangedCallback(uint8_t e * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfElectricalMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfElectricalMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Electrical Measurement Cluster Server Init * * Server Init @@ -24453,7 +21959,7 @@ void emberAfElectricalMeasurementClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfElectricalMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24471,11 +21977,8 @@ void emberAfElectricalMeasurementClusterServerManufacturerSpecificAttributeChang * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfElectricalMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfElectricalMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Electrical Measurement Cluster Server Pre Attribute Changed * @@ -24487,11 +21990,9 @@ void emberAfElectricalMeasurementClusterServerMessageSentCallback(EmberOutgoingM * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfElectricalMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfElectricalMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Electrical Measurement Cluster Server Tick * * Server Tick @@ -24512,8 +22013,7 @@ void emberAfElectricalMeasurementClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDiagnosticsClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDiagnosticsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Diagnostics Cluster Client Default Response * * This function is called when the client receives the default response from @@ -24523,9 +22023,7 @@ void emberAfDiagnosticsClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDiagnosticsClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDiagnosticsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Diagnostics Cluster Client Init * * Client Init @@ -24539,11 +22037,10 @@ void emberAfDiagnosticsClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDiagnosticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDiagnosticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Diagnostics Cluster Client Message Sent * @@ -24557,11 +22054,8 @@ void emberAfDiagnosticsClusterClientManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDiagnosticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDiagnosticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Diagnostics Cluster Client Pre Attribute Changed * @@ -24573,11 +22067,9 @@ void emberAfDiagnosticsClusterClientMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDiagnosticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDiagnosticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Diagnostics Cluster Client Tick * * Client Tick @@ -24592,8 +22084,7 @@ void emberAfDiagnosticsClusterClientTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfDiagnosticsClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfDiagnosticsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Diagnostics Cluster Server Default Response * * This function is called when the server receives the default response from @@ -24603,9 +22094,7 @@ void emberAfDiagnosticsClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfDiagnosticsClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfDiagnosticsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Diagnostics Cluster Server Init * * Server Init @@ -24619,11 +22108,10 @@ void emberAfDiagnosticsClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief Diagnostics Cluster Server Message Sent * @@ -24637,11 +22125,8 @@ void emberAfDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Diagnostics Cluster Server Pre Attribute Changed * @@ -24653,11 +22138,9 @@ void emberAfDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfDiagnosticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfDiagnosticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Diagnostics Cluster Server Tick * * Server Tick @@ -24678,8 +22161,7 @@ void emberAfDiagnosticsClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfZllCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfZllCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief ZLL Commissioning Cluster Client Default Response * * This function is called when the client receives the default response from @@ -24689,9 +22171,7 @@ void emberAfZllCommissioningClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfZllCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfZllCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief ZLL Commissioning Cluster Client Init * * Client Init @@ -24705,7 +22185,7 @@ void emberAfZllCommissioningClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfZllCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -24723,11 +22203,8 @@ void emberAfZllCommissioningClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfZllCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfZllCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief ZLL Commissioning Cluster Client Pre Attribute Changed * @@ -24739,11 +22216,9 @@ void emberAfZllCommissioningClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfZllCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfZllCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief ZLL Commissioning Cluster Client Tick * * Client Tick @@ -24753,16 +22228,15 @@ EmberAfStatus emberAfZllCommissioningClusterClientPreAttributeChangedCallback(ui void emberAfZllCommissioningClusterClientTickCallback(uint8_t endpoint); /** @brief ZLL Commissioning Cluster Device Information Request * - * + * * * @param transaction Ver.: always * @param startIndex Ver.: always */ -bool emberAfZllCommissioningClusterDeviceInformationRequestCallback(uint32_t transaction, - uint8_t startIndex); +bool emberAfZllCommissioningClusterDeviceInformationRequestCallback(uint32_t transaction, uint8_t startIndex); /** @brief ZLL Commissioning Cluster Device Information Response * - * + * * * @param transaction Ver.: always * @param numberOfSubDevices Ver.: always @@ -24770,14 +22244,12 @@ bool emberAfZllCommissioningClusterDeviceInformationRequestCallback(uint32_t tra * @param deviceInformationRecordCount Ver.: always * @param deviceInformationRecordList Ver.: always */ -bool emberAfZllCommissioningClusterDeviceInformationResponseCallback(uint32_t transaction, - uint8_t numberOfSubDevices, - uint8_t startIndex, - uint8_t deviceInformationRecordCount, - uint8_t* deviceInformationRecordList); +bool emberAfZllCommissioningClusterDeviceInformationResponseCallback(uint32_t transaction, uint8_t numberOfSubDevices, + uint8_t startIndex, uint8_t deviceInformationRecordCount, + uint8_t * deviceInformationRecordList); /** @brief ZLL Commissioning Cluster Endpoint Information * - * + * * * @param ieeeAddress Ver.: always * @param networkAddress Ver.: always @@ -24786,64 +22258,55 @@ bool emberAfZllCommissioningClusterDeviceInformationResponseCallback(uint32_t tr * @param deviceId Ver.: always * @param version Ver.: always */ -bool emberAfZllCommissioningClusterEndpointInformationCallback(uint8_t* ieeeAddress, - uint16_t networkAddress, - uint8_t endpointId, - uint16_t profileId, - uint16_t deviceId, - uint8_t version); +bool emberAfZllCommissioningClusterEndpointInformationCallback(uint8_t * ieeeAddress, uint16_t networkAddress, uint8_t endpointId, + uint16_t profileId, uint16_t deviceId, uint8_t version); /** @brief ZLL Commissioning Cluster Get Endpoint List Request * - * + * * * @param startIndex Ver.: always */ bool emberAfZllCommissioningClusterGetEndpointListRequestCallback(uint8_t startIndex); /** @brief ZLL Commissioning Cluster Get Endpoint List Response * - * + * * * @param total Ver.: always * @param startIndex Ver.: always * @param count Ver.: always * @param endpointInformationRecordList Ver.: always */ -bool emberAfZllCommissioningClusterGetEndpointListResponseCallback(uint8_t total, - uint8_t startIndex, - uint8_t count, - uint8_t* endpointInformationRecordList); +bool emberAfZllCommissioningClusterGetEndpointListResponseCallback(uint8_t total, uint8_t startIndex, uint8_t count, + uint8_t * endpointInformationRecordList); /** @brief ZLL Commissioning Cluster Get Group Identifiers Request * - * + * * * @param startIndex Ver.: always */ bool emberAfZllCommissioningClusterGetGroupIdentifiersRequestCallback(uint8_t startIndex); /** @brief ZLL Commissioning Cluster Get Group Identifiers Response * - * + * * * @param total Ver.: always * @param startIndex Ver.: always * @param count Ver.: always * @param groupInformationRecordList Ver.: always */ -bool emberAfZllCommissioningClusterGetGroupIdentifiersResponseCallback(uint8_t total, - uint8_t startIndex, - uint8_t count, - uint8_t* groupInformationRecordList); +bool emberAfZllCommissioningClusterGetGroupIdentifiersResponseCallback(uint8_t total, uint8_t startIndex, uint8_t count, + uint8_t * groupInformationRecordList); /** @brief ZLL Commissioning Cluster Identify Request * - * + * * * @param transaction Ver.: always * @param identifyDuration Ver.: always */ -bool emberAfZllCommissioningClusterIdentifyRequestCallback(uint32_t transaction, - uint16_t identifyDuration); +bool emberAfZllCommissioningClusterIdentifyRequestCallback(uint32_t transaction, uint16_t identifyDuration); /** @brief ZLL Commissioning Cluster Network Join End Device Request * - * + * * * @param transaction Ver.: always * @param extendedPanId Ver.: always @@ -24860,32 +22323,22 @@ bool emberAfZllCommissioningClusterIdentifyRequestCallback(uint32_t transaction, * @param freeGroupIdentifierRangeBegin Ver.: always * @param freeGroupIdentifierRangeEnd Ver.: always */ -bool emberAfZllCommissioningClusterNetworkJoinEndDeviceRequestCallback(uint32_t transaction, - uint8_t* extendedPanId, - uint8_t keyIndex, - uint8_t* encryptedNetworkKey, - uint8_t networkUpdateId, - uint8_t logicalChannel, - uint16_t panId, - uint16_t networkAddress, - uint16_t groupIdentifiersBegin, - uint16_t groupIdentifiersEnd, - uint16_t freeNetworkAddressRangeBegin, - uint16_t freeNetworkAddressRangeEnd, - uint16_t freeGroupIdentifierRangeBegin, - uint16_t freeGroupIdentifierRangeEnd); +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t networkUpdateId, + uint8_t logicalChannel, uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); /** @brief ZLL Commissioning Cluster Network Join End Device Response * - * + * * * @param transaction Ver.: always * @param status Ver.: always */ -bool emberAfZllCommissioningClusterNetworkJoinEndDeviceResponseCallback(uint32_t transaction, - uint8_t status); +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceResponseCallback(uint32_t transaction, uint8_t status); /** @brief ZLL Commissioning Cluster Network Join Router Request * - * + * * * @param transaction Ver.: always * @param extendedPanId Ver.: always @@ -24902,32 +22355,22 @@ bool emberAfZllCommissioningClusterNetworkJoinEndDeviceResponseCallback(uint32_t * @param freeGroupIdentifierRangeBegin Ver.: always * @param freeGroupIdentifierRangeEnd Ver.: always */ -bool emberAfZllCommissioningClusterNetworkJoinRouterRequestCallback(uint32_t transaction, - uint8_t* extendedPanId, - uint8_t keyIndex, - uint8_t* encryptedNetworkKey, - uint8_t networkUpdateId, - uint8_t logicalChannel, - uint16_t panId, - uint16_t networkAddress, - uint16_t groupIdentifiersBegin, - uint16_t groupIdentifiersEnd, - uint16_t freeNetworkAddressRangeBegin, - uint16_t freeNetworkAddressRangeEnd, - uint16_t freeGroupIdentifierRangeBegin, - uint16_t freeGroupIdentifierRangeEnd); +bool emberAfZllCommissioningClusterNetworkJoinRouterRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t networkUpdateId, + uint8_t logicalChannel, uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); /** @brief ZLL Commissioning Cluster Network Join Router Response * - * + * * * @param transaction Ver.: always * @param status Ver.: always */ -bool emberAfZllCommissioningClusterNetworkJoinRouterResponseCallback(uint32_t transaction, - uint8_t status); +bool emberAfZllCommissioningClusterNetworkJoinRouterResponseCallback(uint32_t transaction, uint8_t status); /** @brief ZLL Commissioning Cluster Network Start Request * - * + * * * @param transaction Ver.: always * @param extendedPanId Ver.: always @@ -24945,24 +22388,14 @@ bool emberAfZllCommissioningClusterNetworkJoinRouterResponseCallback(uint32_t tr * @param initiatorIeeeAddress Ver.: always * @param initiatorNetworkAddress Ver.: always */ -bool emberAfZllCommissioningClusterNetworkStartRequestCallback(uint32_t transaction, - uint8_t* extendedPanId, - uint8_t keyIndex, - uint8_t* encryptedNetworkKey, - uint8_t logicalChannel, - uint16_t panId, - uint16_t networkAddress, - uint16_t groupIdentifiersBegin, - uint16_t groupIdentifiersEnd, - uint16_t freeNetworkAddressRangeBegin, - uint16_t freeNetworkAddressRangeEnd, - uint16_t freeGroupIdentifierRangeBegin, - uint16_t freeGroupIdentifierRangeEnd, - uint8_t* initiatorIeeeAddress, - uint16_t initiatorNetworkAddress); +bool emberAfZllCommissioningClusterNetworkStartRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t logicalChannel, + uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd, uint8_t * initiatorIeeeAddress, uint16_t initiatorNetworkAddress); /** @brief ZLL Commissioning Cluster Network Start Response * - * + * * * @param transaction Ver.: always * @param status Ver.: always @@ -24971,15 +22404,11 @@ bool emberAfZllCommissioningClusterNetworkStartRequestCallback(uint32_t transact * @param logicalChannel Ver.: always * @param panId Ver.: always */ -bool emberAfZllCommissioningClusterNetworkStartResponseCallback(uint32_t transaction, - uint8_t status, - uint8_t* extendedPanId, - uint8_t networkUpdateId, - uint8_t logicalChannel, - uint16_t panId); +bool emberAfZllCommissioningClusterNetworkStartResponseCallback(uint32_t transaction, uint8_t status, uint8_t * extendedPanId, + uint8_t networkUpdateId, uint8_t logicalChannel, uint16_t panId); /** @brief ZLL Commissioning Cluster Network Update Request * - * + * * * @param transaction Ver.: always * @param extendedPanId Ver.: always @@ -24988,33 +22417,28 @@ bool emberAfZllCommissioningClusterNetworkStartResponseCallback(uint32_t transac * @param panId Ver.: always * @param networkAddress Ver.: always */ -bool emberAfZllCommissioningClusterNetworkUpdateRequestCallback(uint32_t transaction, - uint8_t* extendedPanId, - uint8_t networkUpdateId, - uint8_t logicalChannel, - uint16_t panId, - uint16_t networkAddress); +bool emberAfZllCommissioningClusterNetworkUpdateRequestCallback(uint32_t transaction, uint8_t * extendedPanId, + uint8_t networkUpdateId, uint8_t logicalChannel, uint16_t panId, + uint16_t networkAddress); /** @brief ZLL Commissioning Cluster Reset To Factory New Request * - * + * * * @param transaction Ver.: always */ bool emberAfZllCommissioningClusterResetToFactoryNewRequestCallback(uint32_t transaction); /** @brief ZLL Commissioning Cluster Scan Request * - * + * * * @param transaction Ver.: always * @param zigbeeInformation Ver.: always * @param zllInformation Ver.: always */ -bool emberAfZllCommissioningClusterScanRequestCallback(uint32_t transaction, - uint8_t zigbeeInformation, - uint8_t zllInformation); +bool emberAfZllCommissioningClusterScanRequestCallback(uint32_t transaction, uint8_t zigbeeInformation, uint8_t zllInformation); /** @brief ZLL Commissioning Cluster Scan Response * - * + * * * @param transaction Ver.: always * @param rssiCorrection Ver.: always @@ -25035,24 +22459,12 @@ bool emberAfZllCommissioningClusterScanRequestCallback(uint32_t transaction, * @param version Ver.: always * @param groupIdCount Ver.: always */ -bool emberAfZllCommissioningClusterScanResponseCallback(uint32_t transaction, - uint8_t rssiCorrection, - uint8_t zigbeeInformation, - uint8_t zllInformation, - uint16_t keyBitmask, - uint32_t responseId, - uint8_t* extendedPanId, - uint8_t networkUpdateId, - uint8_t logicalChannel, - uint16_t panId, - uint16_t networkAddress, - uint8_t numberOfSubDevices, - uint8_t totalGroupIds, - uint8_t endpointId, - uint16_t profileId, - uint16_t deviceId, - uint8_t version, - uint8_t groupIdCount); +bool emberAfZllCommissioningClusterScanResponseCallback(uint32_t transaction, uint8_t rssiCorrection, uint8_t zigbeeInformation, + uint8_t zllInformation, uint16_t keyBitmask, uint32_t responseId, + uint8_t * extendedPanId, uint8_t networkUpdateId, uint8_t logicalChannel, + uint16_t panId, uint16_t networkAddress, uint8_t numberOfSubDevices, + uint8_t totalGroupIds, uint8_t endpointId, uint16_t profileId, + uint16_t deviceId, uint8_t version, uint8_t groupIdCount); /** @brief ZLL Commissioning Cluster Server Attribute Changed * * Server Attribute Changed @@ -25060,8 +22472,7 @@ bool emberAfZllCommissioningClusterScanResponseCallback(uint32_t transaction, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfZllCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfZllCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief ZLL Commissioning Cluster Server Default Response * * This function is called when the server receives the default response from @@ -25071,9 +22482,7 @@ void emberAfZllCommissioningClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfZllCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfZllCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief ZLL Commissioning Cluster Server Init * * Server Init @@ -25087,7 +22496,7 @@ void emberAfZllCommissioningClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfZllCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25105,11 +22514,8 @@ void emberAfZllCommissioningClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfZllCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfZllCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief ZLL Commissioning Cluster Server Pre Attribute Changed * @@ -25121,11 +22527,9 @@ void emberAfZllCommissioningClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfZllCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfZllCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief ZLL Commissioning Cluster Server Tick * * Server Tick @@ -25146,8 +22550,7 @@ void emberAfZllCommissioningClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSampleMfgSpecificClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSampleMfgSpecificClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sample Mfg Specific Cluster Cluster Client Default Response * * This function is called when the client receives the default response from @@ -25157,9 +22560,7 @@ void emberAfSampleMfgSpecificClusterClientAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSampleMfgSpecificClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSampleMfgSpecificClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sample Mfg Specific Cluster Cluster Client Init * * Client Init @@ -25173,7 +22574,7 @@ void emberAfSampleMfgSpecificClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSampleMfgSpecificClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25191,11 +22592,8 @@ void emberAfSampleMfgSpecificClusterClientManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSampleMfgSpecificClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSampleMfgSpecificClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sample Mfg Specific Cluster Cluster Client Pre Attribute Changed * @@ -25207,11 +22605,9 @@ void emberAfSampleMfgSpecificClusterClientMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSampleMfgSpecificClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSampleMfgSpecificClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sample Mfg Specific Cluster Cluster Client Tick * * Client Tick @@ -25221,7 +22617,7 @@ EmberAfStatus emberAfSampleMfgSpecificClusterClientPreAttributeChangedCallback(u void emberAfSampleMfgSpecificClusterClientTickCallback(uint8_t endpoint); /** @brief Sample Mfg Specific Cluster Cluster Command One * - * + * * * @param argOne Ver.: always */ @@ -25233,8 +22629,7 @@ bool emberAfSampleMfgSpecificClusterCommandOneCallback(uint8_t argOne); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSampleMfgSpecificClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSampleMfgSpecificClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sample Mfg Specific Cluster Cluster Server Default Response * * This function is called when the server receives the default response from @@ -25244,9 +22639,7 @@ void emberAfSampleMfgSpecificClusterServerAttributeChangedCallback(uint8_t endpo * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSampleMfgSpecificClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSampleMfgSpecificClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sample Mfg Specific Cluster Cluster Server Init * * Server Init @@ -25260,7 +22653,7 @@ void emberAfSampleMfgSpecificClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSampleMfgSpecificClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25278,11 +22671,8 @@ void emberAfSampleMfgSpecificClusterServerManufacturerSpecificAttributeChangedCa * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSampleMfgSpecificClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSampleMfgSpecificClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sample Mfg Specific Cluster Cluster Server Pre Attribute Changed * @@ -25294,11 +22684,9 @@ void emberAfSampleMfgSpecificClusterServerMessageSentCallback(EmberOutgoingMessa * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSampleMfgSpecificClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSampleMfgSpecificClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sample Mfg Specific Cluster Cluster Server Tick * * Server Tick @@ -25319,8 +22707,7 @@ void emberAfSampleMfgSpecificClusterServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSampleMfgSpecificCluster2ClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSampleMfgSpecificCluster2ClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sample Mfg Specific Cluster 2 Cluster Client Default Response * * This function is called when the client receives the default response from @@ -25330,9 +22717,7 @@ void emberAfSampleMfgSpecificCluster2ClientAttributeChangedCallback(uint8_t endp * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSampleMfgSpecificCluster2ClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSampleMfgSpecificCluster2ClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sample Mfg Specific Cluster 2 Cluster Client Init * * Client Init @@ -25346,7 +22731,7 @@ void emberAfSampleMfgSpecificCluster2ClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSampleMfgSpecificCluster2ClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25364,11 +22749,8 @@ void emberAfSampleMfgSpecificCluster2ClientManufacturerSpecificAttributeChangedC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSampleMfgSpecificCluster2ClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSampleMfgSpecificCluster2ClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sample Mfg Specific Cluster 2 Cluster Client Pre Attribute Changed * @@ -25380,11 +22762,9 @@ void emberAfSampleMfgSpecificCluster2ClientMessageSentCallback(EmberOutgoingMess * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSampleMfgSpecificCluster2ClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSampleMfgSpecificCluster2ClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sample Mfg Specific Cluster 2 Cluster Client Tick * * Client Tick @@ -25394,7 +22774,7 @@ EmberAfStatus emberAfSampleMfgSpecificCluster2ClientPreAttributeChangedCallback( void emberAfSampleMfgSpecificCluster2ClientTickCallback(uint8_t endpoint); /** @brief Sample Mfg Specific Cluster 2 Cluster Command Two * - * + * * * @param argOne Ver.: always */ @@ -25406,8 +22786,7 @@ bool emberAfSampleMfgSpecificCluster2CommandTwoCallback(uint8_t argOne); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSampleMfgSpecificCluster2ServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSampleMfgSpecificCluster2ServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Sample Mfg Specific Cluster 2 Cluster Server Default Response * * This function is called when the server receives the default response from @@ -25417,9 +22796,7 @@ void emberAfSampleMfgSpecificCluster2ServerAttributeChangedCallback(uint8_t endp * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSampleMfgSpecificCluster2ServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSampleMfgSpecificCluster2ServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Sample Mfg Specific Cluster 2 Cluster Server Init * * Server Init @@ -25433,7 +22810,7 @@ void emberAfSampleMfgSpecificCluster2ServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfSampleMfgSpecificCluster2ServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25451,11 +22828,8 @@ void emberAfSampleMfgSpecificCluster2ServerManufacturerSpecificAttributeChangedC * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSampleMfgSpecificCluster2ServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSampleMfgSpecificCluster2ServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Sample Mfg Specific Cluster 2 Cluster Server Pre Attribute Changed * @@ -25467,11 +22841,9 @@ void emberAfSampleMfgSpecificCluster2ServerMessageSentCallback(EmberOutgoingMess * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSampleMfgSpecificCluster2ServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSampleMfgSpecificCluster2ServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Sample Mfg Specific Cluster 2 Cluster Server Tick * * Server Tick @@ -25492,8 +22864,7 @@ void emberAfSampleMfgSpecificCluster2ServerTickCallback(uint8_t endpoint); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOtaConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOtaConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Configuration Cluster Cluster Client Default Response * * This function is called when the client receives the default response from @@ -25503,9 +22874,7 @@ void emberAfOtaConfigurationClusterClientAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOtaConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOtaConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Configuration Cluster Cluster Client Init * * Client Init @@ -25519,7 +22888,7 @@ void emberAfOtaConfigurationClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOtaConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25537,11 +22906,8 @@ void emberAfOtaConfigurationClusterClientManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOtaConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOtaConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Configuration Cluster Cluster Client Pre Attribute Changed * @@ -25553,11 +22919,9 @@ void emberAfOtaConfigurationClusterClientMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOtaConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOtaConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Configuration Cluster Cluster Client Tick * * Client Tick @@ -25567,26 +22931,25 @@ EmberAfStatus emberAfOtaConfigurationClusterClientPreAttributeChangedCallback(ui void emberAfOtaConfigurationClusterClientTickCallback(uint8_t endpoint); /** @brief Configuration Cluster Cluster Lock Tokens * - * + * * */ bool emberAfOtaConfigurationClusterLockTokensCallback(void); /** @brief Configuration Cluster Cluster Read Tokens * - * + * * * @param token Ver.: always */ bool emberAfOtaConfigurationClusterReadTokensCallback(uint16_t token); /** @brief Configuration Cluster Cluster Return Token * - * + * * * @param token Ver.: always * @param data Ver.: always */ -bool emberAfOtaConfigurationClusterReturnTokenCallback(uint16_t token, - uint8_t* data); +bool emberAfOtaConfigurationClusterReturnTokenCallback(uint16_t token, uint8_t * data); /** @brief Configuration Cluster Cluster Server Attribute Changed * * Server Attribute Changed @@ -25594,8 +22957,7 @@ bool emberAfOtaConfigurationClusterReturnTokenCallback(uint16_t token, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfOtaConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfOtaConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief Configuration Cluster Cluster Server Default Response * * This function is called when the server receives the default response from @@ -25605,9 +22967,7 @@ void emberAfOtaConfigurationClusterServerAttributeChangedCallback(uint8_t endpoi * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfOtaConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfOtaConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief Configuration Cluster Cluster Server Init * * Server Init @@ -25621,7 +22981,7 @@ void emberAfOtaConfigurationClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ void emberAfOtaConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, @@ -25639,11 +22999,8 @@ void emberAfOtaConfigurationClusterServerManufacturerSpecificAttributeChangedCal * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfOtaConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfOtaConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief Configuration Cluster Cluster Server Pre Attribute Changed * @@ -25655,11 +23012,9 @@ void emberAfOtaConfigurationClusterServerMessageSentCallback(EmberOutgoingMessag * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfOtaConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfOtaConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief Configuration Cluster Cluster Server Tick * * Server Tick @@ -25669,20 +23024,19 @@ EmberAfStatus emberAfOtaConfigurationClusterServerPreAttributeChangedCallback(ui void emberAfOtaConfigurationClusterServerTickCallback(uint8_t endpoint); /** @brief Configuration Cluster Cluster Set Token * - * + * * * @param token Ver.: always * @param data Ver.: always */ -bool emberAfOtaConfigurationClusterSetTokenCallback(uint16_t token, - uint8_t* data); +bool emberAfOtaConfigurationClusterSetTokenCallback(uint16_t token, uint8_t * data); /** @brief Configuration Cluster Cluster Unlock Tokens * - * + * * * @param data Ver.: always */ -bool emberAfOtaConfigurationClusterUnlockTokensCallback(uint8_t* data); +bool emberAfOtaConfigurationClusterUnlockTokensCallback(uint8_t * data); /** @} END Configuration Cluster Cluster Callbacks */ @@ -25696,8 +23050,7 @@ bool emberAfOtaConfigurationClusterUnlockTokensCallback(uint8_t* data); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMfglibClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMfglibClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief MFGLIB Cluster Cluster Client Default Response * * This function is called when the client receives the default response from @@ -25707,9 +23060,7 @@ void emberAfMfglibClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMfglibClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMfglibClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief MFGLIB Cluster Cluster Client Init * * Client Init @@ -25723,11 +23074,10 @@ void emberAfMfglibClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMfglibClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMfglibClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief MFGLIB Cluster Cluster Client Message Sent * @@ -25741,11 +23091,8 @@ void emberAfMfglibClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMfglibClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMfglibClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief MFGLIB Cluster Cluster Client Pre Attribute Changed * @@ -25757,11 +23104,9 @@ void emberAfMfglibClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMfglibClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMfglibClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief MFGLIB Cluster Cluster Client Tick * * Client Tick @@ -25771,15 +23116,13 @@ EmberAfStatus emberAfMfglibClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfMfglibClusterClientTickCallback(uint8_t endpoint); /** @brief MFGLIB Cluster Cluster Rx Mode * - * + * * * @param channel Ver.: always * @param power Ver.: always * @param time Ver.: always */ -bool emberAfMfglibClusterRxModeCallback(uint8_t channel, - int8_t power, - uint16_t time); +bool emberAfMfglibClusterRxModeCallback(uint8_t channel, int8_t power, uint16_t time); /** @brief MFGLIB Cluster Cluster Server Attribute Changed * * Server Attribute Changed @@ -25787,8 +23130,7 @@ bool emberAfMfglibClusterRxModeCallback(uint8_t channel, * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfMfglibClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfMfglibClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief MFGLIB Cluster Cluster Server Default Response * * This function is called when the server receives the default response from @@ -25798,9 +23140,7 @@ void emberAfMfglibClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfMfglibClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfMfglibClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief MFGLIB Cluster Cluster Server Init * * Server Init @@ -25814,11 +23154,10 @@ void emberAfMfglibClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfMfglibClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfMfglibClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief MFGLIB Cluster Cluster Server Message Sent * @@ -25832,11 +23171,8 @@ void emberAfMfglibClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfMfglibClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfMfglibClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief MFGLIB Cluster Cluster Server Pre Attribute Changed * @@ -25848,11 +23184,9 @@ void emberAfMfglibClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfMfglibClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfMfglibClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief MFGLIB Cluster Cluster Server Tick * * Server Tick @@ -25862,26 +23196,22 @@ EmberAfStatus emberAfMfglibClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfMfglibClusterServerTickCallback(uint8_t endpoint); /** @brief MFGLIB Cluster Cluster Stream * - * + * * * @param channel Ver.: always * @param power Ver.: always * @param time Ver.: always */ -bool emberAfMfglibClusterStreamCallback(uint8_t channel, - int8_t power, - uint16_t time); +bool emberAfMfglibClusterStreamCallback(uint8_t channel, int8_t power, uint16_t time); /** @brief MFGLIB Cluster Cluster Tone * - * + * * * @param channel Ver.: always * @param power Ver.: always * @param time Ver.: always */ -bool emberAfMfglibClusterToneCallback(uint8_t channel, - int8_t power, - uint16_t time); +bool emberAfMfglibClusterToneCallback(uint8_t channel, int8_t power, uint16_t time); /** @} END MFGLIB Cluster Cluster Callbacks */ @@ -25890,38 +23220,36 @@ bool emberAfMfglibClusterToneCallback(uint8_t channel, /** @brief SL Works With All Hubs Cluster Aps Ack Enablement Query Response * - * + * * * @param numberExemptClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterApsAckEnablementQueryResponseCallback(uint8_t numberExemptClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterApsAckEnablementQueryResponseCallback(uint8_t numberExemptClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Aps Ack Requirement Query * - * + * * */ bool emberAfSlWwahClusterApsAckRequirementQueryCallback(void); /** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query * - * + * * * @param clusterId Ver.: always */ bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryCallback(uint16_t clusterId); /** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query Response * - * + * * * @param clusterId Ver.: always * @param apsLinkKeyAuthStatus Ver.: always */ -bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryResponseCallback(uint16_t clusterId, - uint8_t apsLinkKeyAuthStatus); +bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryResponseCallback(uint16_t clusterId, uint8_t apsLinkKeyAuthStatus); /** @brief SL Works With All Hubs Cluster Clear Binding Table * - * + * * */ bool emberAfSlWwahClusterClearBindingTableCallback(void); @@ -25932,8 +23260,7 @@ bool emberAfSlWwahClusterClearBindingTableCallback(void); * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSlWwahClusterClientAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSlWwahClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief SL Works With All Hubs Cluster Client Default Response * * This function is called when the client receives the default response from @@ -25943,9 +23270,7 @@ void emberAfSlWwahClusterClientAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSlWwahClusterClientDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSlWwahClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief SL Works With All Hubs Cluster Client Init * * Client Init @@ -25959,11 +23284,10 @@ void emberAfSlWwahClusterClientInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSlWwahClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfSlWwahClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief SL Works With All Hubs Cluster Client Message Sent * @@ -25977,11 +23301,8 @@ void emberAfSlWwahClusterClientManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSlWwahClusterClientMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSlWwahClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief SL Works With All Hubs Cluster Client Pre Attribute Changed * @@ -25993,11 +23314,9 @@ void emberAfSlWwahClusterClientMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSlWwahClusterClientPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSlWwahClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief SL Works With All Hubs Cluster Client Tick * * Client Tick @@ -26007,139 +23326,134 @@ EmberAfStatus emberAfSlWwahClusterClientPreAttributeChangedCallback(uint8_t endp void emberAfSlWwahClusterClientTickCallback(uint8_t endpoint); /** @brief SL Works With All Hubs Cluster Debug Report Query * - * + * * * @param debugReportId Ver.: always */ bool emberAfSlWwahClusterDebugReportQueryCallback(uint8_t debugReportId); /** @brief SL Works With All Hubs Cluster Debug Report Query Response * - * + * * * @param debugReportId Ver.: always * @param debugReportData Ver.: always */ -bool emberAfSlWwahClusterDebugReportQueryResponseCallback(uint8_t debugReportId, - uint8_t* debugReportData); +bool emberAfSlWwahClusterDebugReportQueryResponseCallback(uint8_t debugReportId, uint8_t * debugReportData); /** @brief SL Works With All Hubs Cluster Disable Aps Link Key Authorization * - * + * * * @param numberExemptClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterDisableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterDisableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Disable Configuration Mode * - * + * * */ bool emberAfSlWwahClusterDisableConfigurationModeCallback(void); /** @brief SL Works With All Hubs Cluster Disable Mgmt Leave Without Rejoin * - * + * * */ bool emberAfSlWwahClusterDisableMgmtLeaveWithoutRejoinCallback(void); /** @brief SL Works With All Hubs Cluster Disable Ota Downgrades * - * + * * */ bool emberAfSlWwahClusterDisableOtaDowngradesCallback(void); /** @brief SL Works With All Hubs Cluster Disable Periodic Router Check Ins * - * + * * */ bool emberAfSlWwahClusterDisablePeriodicRouterCheckInsCallback(void); /** @brief SL Works With All Hubs Cluster Disable Touchlink Interpan Message Support * - * + * * */ bool emberAfSlWwahClusterDisableTouchlinkInterpanMessageSupportCallback(void); /** @brief SL Works With All Hubs Cluster Disable Wwah App Event Retry Algorithm * - * + * * */ bool emberAfSlWwahClusterDisableWwahAppEventRetryAlgorithmCallback(void); /** @brief SL Works With All Hubs Cluster Disable Wwah Bad Parent Recovery * - * + * * */ bool emberAfSlWwahClusterDisableWwahBadParentRecoveryCallback(void); /** @brief SL Works With All Hubs Cluster Disable Wwah Parent Classification * - * + * * */ bool emberAfSlWwahClusterDisableWwahParentClassificationCallback(void); /** @brief SL Works With All Hubs Cluster Disable Wwah Rejoin Algorithm * - * + * * */ bool emberAfSlWwahClusterDisableWwahRejoinAlgorithmCallback(void); /** @brief SL Works With All Hubs Cluster Enable Aps Link Key Authorization * - * + * * * @param numberExemptClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterEnableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterEnableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Enable Configuration Mode * - * + * * */ bool emberAfSlWwahClusterEnableConfigurationModeCallback(void); /** @brief SL Works With All Hubs Cluster Enable Periodic Router Check Ins * - * + * * * @param checkInInterval Ver.: always */ bool emberAfSlWwahClusterEnablePeriodicRouterCheckInsCallback(uint16_t checkInInterval); /** @brief SL Works With All Hubs Cluster Enable Tc Security On Ntwk Key Rotation * - * + * * */ bool emberAfSlWwahClusterEnableTcSecurityOnNtwkKeyRotationCallback(void); /** @brief SL Works With All Hubs Cluster Enable Wwah App Event Retry Algorithm * - * + * * * @param firstBackoffTimeSeconds Ver.: always * @param backoffSeqCommonRatio Ver.: always * @param maxBackoffTimeSeconds Ver.: always * @param maxRedeliveryAttempts Ver.: always */ -bool emberAfSlWwahClusterEnableWwahAppEventRetryAlgorithmCallback(uint8_t firstBackoffTimeSeconds, - uint8_t backoffSeqCommonRatio, - uint32_t maxBackoffTimeSeconds, - uint8_t maxRedeliveryAttempts); +bool emberAfSlWwahClusterEnableWwahAppEventRetryAlgorithmCallback(uint8_t firstBackoffTimeSeconds, uint8_t backoffSeqCommonRatio, + uint32_t maxBackoffTimeSeconds, uint8_t maxRedeliveryAttempts); /** @brief SL Works With All Hubs Cluster Enable Wwah Bad Parent Recovery * - * + * * */ bool emberAfSlWwahClusterEnableWwahBadParentRecoveryCallback(void); /** @brief SL Works With All Hubs Cluster Enable Wwah Parent Classification * - * + * * */ bool emberAfSlWwahClusterEnableWwahParentClassificationCallback(void); /** @brief SL Works With All Hubs Cluster Enable Wwah Rejoin Algorithm * - * + * * * @param fastRejoinTimeoutSeconds Ver.: always * @param durationBetweenRejoinsSeconds Ver.: always @@ -26148,85 +23462,76 @@ bool emberAfSlWwahClusterEnableWwahParentClassificationCallback(void); * @param maxBackoffIterations Ver.: always */ bool emberAfSlWwahClusterEnableWwahRejoinAlgorithmCallback(uint16_t fastRejoinTimeoutSeconds, - uint16_t durationBetweenRejoinsSeconds, - uint16_t fastRejoinFirstBackoffSeconds, - uint16_t maxBackoffTimeSeconds, - uint16_t maxBackoffIterations); + uint16_t durationBetweenRejoinsSeconds, + uint16_t fastRejoinFirstBackoffSeconds, uint16_t maxBackoffTimeSeconds, + uint16_t maxBackoffIterations); /** @brief SL Works With All Hubs Cluster New Debug Report Notification * - * + * * * @param debugReportId Ver.: always * @param debugReportSize Ver.: always */ -bool emberAfSlWwahClusterNewDebugReportNotificationCallback(uint8_t debugReportId, - uint32_t debugReportSize); +bool emberAfSlWwahClusterNewDebugReportNotificationCallback(uint8_t debugReportId, uint32_t debugReportSize); /** @brief SL Works With All Hubs Cluster Power Descriptor Change * - * + * * * @param currentPowerMode Ver.: always * @param availablePowerSources Ver.: always * @param currentPowerSource Ver.: always * @param currentPowerSourceLevel Ver.: always */ -bool emberAfSlWwahClusterPowerDescriptorChangeCallback(uint32_t currentPowerMode, - uint32_t availablePowerSources, - uint32_t currentPowerSource, - uint32_t currentPowerSourceLevel); +bool emberAfSlWwahClusterPowerDescriptorChangeCallback(uint32_t currentPowerMode, uint32_t availablePowerSources, + uint32_t currentPowerSource, uint32_t currentPowerSourceLevel); /** @brief SL Works With All Hubs Cluster Powering Off Notification * - * + * * * @param powerNotificationReason Ver.: always * @param manufacturerId Ver.: always * @param manufacturerReasonLength Ver.: always * @param manufacturerReason Ver.: always */ -bool emberAfSlWwahClusterPoweringOffNotificationCallback(uint8_t powerNotificationReason, - uint16_t manufacturerId, - uint8_t manufacturerReasonLength, - uint8_t* manufacturerReason); +bool emberAfSlWwahClusterPoweringOffNotificationCallback(uint8_t powerNotificationReason, uint16_t manufacturerId, + uint8_t manufacturerReasonLength, uint8_t * manufacturerReason); /** @brief SL Works With All Hubs Cluster Powering On Notification * - * + * * * @param powerNotificationReason Ver.: always * @param manufacturerId Ver.: always * @param manufacturerReasonLength Ver.: always * @param manufacturerReason Ver.: always */ -bool emberAfSlWwahClusterPoweringOnNotificationCallback(uint8_t powerNotificationReason, - uint16_t manufacturerId, - uint8_t manufacturerReasonLength, - uint8_t* manufacturerReason); +bool emberAfSlWwahClusterPoweringOnNotificationCallback(uint8_t powerNotificationReason, uint16_t manufacturerId, + uint8_t manufacturerReasonLength, uint8_t * manufacturerReason); /** @brief SL Works With All Hubs Cluster Remove Aps Acks On Unicasts Requirement * - * + * * */ bool emberAfSlWwahClusterRemoveApsAcksOnUnicastsRequirementCallback(void); /** @brief SL Works With All Hubs Cluster Request New Aps Link Key * - * + * * */ bool emberAfSlWwahClusterRequestNewApsLinkKeyCallback(void); /** @brief SL Works With All Hubs Cluster Request Time * - * + * * */ bool emberAfSlWwahClusterRequestTimeCallback(void); /** @brief SL Works With All Hubs Cluster Require Aps Acks On Unicasts * - * + * * * @param numberExemptClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterRequireApsAcksOnUnicastsCallback(uint8_t numberExemptClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterRequireApsAcksOnUnicastsCallback(uint8_t numberExemptClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Server Attribute Changed * * Server Attribute Changed @@ -26234,8 +23539,7 @@ bool emberAfSlWwahClusterRequireApsAcksOnUnicastsCallback(uint8_t numberExemptCl * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always */ -void emberAfSlWwahClusterServerAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId); +void emberAfSlWwahClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); /** @brief SL Works With All Hubs Cluster Server Default Response * * This function is called when the server receives the default response from @@ -26245,9 +23549,7 @@ void emberAfSlWwahClusterServerAttributeChangedCallback(uint8_t endpoint, * @param commandId Command id Ver.: always * @param status Status in default response Ver.: always */ -void emberAfSlWwahClusterServerDefaultResponseCallback(uint8_t endpoint, - uint8_t commandId, - EmberAfStatus status); +void emberAfSlWwahClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); /** @brief SL Works With All Hubs Cluster Server Init * * Server Init @@ -26261,11 +23563,10 @@ void emberAfSlWwahClusterServerInitCallback(uint8_t endpoint); * * @param endpoint Endpoint that is being initialized Ver.: always * @param attributeId Attribute that changed Ver.: always - * @param manufacturerCode Manufacturer Code of the attribute that changed + * @param manufacturerCode Manufacturer Code of the attribute that changed * Ver.: always */ -void emberAfSlWwahClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, +void emberAfSlWwahClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); /** @brief SL Works With All Hubs Cluster Server Message Sent * @@ -26279,11 +23580,8 @@ void emberAfSlWwahClusterServerManufacturerSpecificAttributeChangedCallback(uint * @param message The message that was sent Ver.: always * @param status The status of the sent message Ver.: always */ -void emberAfSlWwahClusterServerMessageSentCallback(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame, - uint16_t msgLen, - uint8_t *message, +void emberAfSlWwahClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); /** @brief SL Works With All Hubs Cluster Server Pre Attribute Changed * @@ -26295,11 +23593,9 @@ void emberAfSlWwahClusterServerMessageSentCallback(EmberOutgoingMessageType type * @param size Attribute size Ver.: always * @param value Attribute value Ver.: always */ -EmberAfStatus emberAfSlWwahClusterServerPreAttributeChangedCallback(uint8_t endpoint, - EmberAfAttributeId attributeId, - EmberAfAttributeType attributeType, - uint8_t size, - uint8_t *value); +EmberAfStatus emberAfSlWwahClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); /** @brief SL Works With All Hubs Cluster Server Tick * * Server Tick @@ -26309,91 +23605,84 @@ EmberAfStatus emberAfSlWwahClusterServerPreAttributeChangedCallback(uint8_t endp void emberAfSlWwahClusterServerTickCallback(uint8_t endpoint); /** @brief SL Works With All Hubs Cluster Set Ias Zone Enrollment Method * - * + * * * @param enrollmentMode Ver.: always */ bool emberAfSlWwahClusterSetIasZoneEnrollmentMethodCallback(uint8_t enrollmentMode); /** @brief SL Works With All Hubs Cluster Set Mac Poll Failure Wait Time * - * + * * * @param waitTime Ver.: always */ bool emberAfSlWwahClusterSetMacPollFailureWaitTimeCallback(uint8_t waitTime); /** @brief SL Works With All Hubs Cluster Set Pending Network Update * - * + * * * @param channel Ver.: always * @param panId Ver.: always */ -bool emberAfSlWwahClusterSetPendingNetworkUpdateCallback(uint8_t channel, - uint16_t panId); +bool emberAfSlWwahClusterSetPendingNetworkUpdateCallback(uint8_t channel, uint16_t panId); /** @brief SL Works With All Hubs Cluster Short Address Change * - * + * * * @param deviceEui64 Ver.: always * @param deviceShort Ver.: always */ -bool emberAfSlWwahClusterShortAddressChangeCallback(uint8_t* deviceEui64, - uint16_t deviceShort); +bool emberAfSlWwahClusterShortAddressChangeCallback(uint8_t * deviceEui64, uint16_t deviceShort); /** @brief SL Works With All Hubs Cluster Survey Beacons * - * + * * * @param standardBeacons Ver.: always */ bool emberAfSlWwahClusterSurveyBeaconsCallback(uint8_t standardBeacons); /** @brief SL Works With All Hubs Cluster Survey Beacons Response * - * + * * * @param numberOfBeacons Ver.: always * @param beacon Ver.: always */ -bool emberAfSlWwahClusterSurveyBeaconsResponseCallback(uint8_t numberOfBeacons, - uint8_t* beacon); +bool emberAfSlWwahClusterSurveyBeaconsResponseCallback(uint8_t numberOfBeacons, uint8_t * beacon); /** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query * - * + * * */ bool emberAfSlWwahClusterTrustCenterForClusterServerQueryCallback(void); /** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query Response * - * + * * * @param numberOfClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterTrustCenterForClusterServerQueryResponseCallback(uint8_t numberOfClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterTrustCenterForClusterServerQueryResponseCallback(uint8_t numberOfClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server * - * + * * * @param numberOfClusters Ver.: always * @param clusterId Ver.: always */ -bool emberAfSlWwahClusterUseTrustCenterForClusterServerCallback(uint8_t numberOfClusters, - uint8_t* clusterId); +bool emberAfSlWwahClusterUseTrustCenterForClusterServerCallback(uint8_t numberOfClusters, uint8_t * clusterId); /** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server Response * - * + * * * @param status Ver.: always * @param clusterStatusLength Ver.: always * @param clusterStatus Ver.: always */ -bool emberAfSlWwahClusterUseTrustCenterForClusterServerResponseCallback(uint8_t status, - uint8_t clusterStatusLength, - uint8_t* clusterStatus); +bool emberAfSlWwahClusterUseTrustCenterForClusterServerResponseCallback(uint8_t status, uint8_t clusterStatusLength, + uint8_t * clusterStatus); /** @} END SL Works With All Hubs Cluster Callbacks */ - /** @name Update TC Link Key Plugin Callbacks */ // @{ @@ -26410,7 +23699,6 @@ bool emberAfSlWwahClusterUseTrustCenterForClusterServerResponseCallback(uint8_t void emberAfPluginUpdateTcLinkKeyStatusCallback(EmberKeyStatus keyStatus); /** @} END Update TC Link Key Plugin Callbacks */ - /** @name Network Steering Plugin Callbacks */ // @{ @@ -26429,9 +23717,7 @@ void emberAfPluginUpdateTcLinkKeyStatusCallback(EmberKeyStatus keyStatus); * this, one is able to tell on which channel mask and with which key the * process was complete. Ver.: always */ -void emberAfPluginNetworkSteeringCompleteCallback(EmberStatus status, - uint8_t totalBeacons, - uint8_t joinAttempts, +void emberAfPluginNetworkSteeringCompleteCallback(EmberStatus status, uint8_t totalBeacons, uint8_t joinAttempts, uint8_t finalState); /** @brief Get Power For Radio Channel * @@ -26467,7 +23753,6 @@ bool emberAfPluginNetworkSteeringGetDistributedKeyCallback(EmberKeyData * key); EmberNodeType emberAfPluginNetworkSteeringGetNodeTypeCallback(EmberAfPluginNetworkSteeringJoiningState state); /** @} END Network Steering Plugin Callbacks */ - /** @name HAL Library Plugin Callbacks */ // @{ @@ -26488,6 +23773,5 @@ void halRadioPowerDownHandler(void); void halSleepCallback(boolean enter, SleepModes sleepMode); /** @} END HAL Library Plugin Callbacks */ - /** @} END addtogroup */ #endif // SILABS_EMBER_AF_CALLBACK_PROTOTYPES diff --git a/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h b/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h index 5b2509a6c2191e..95d50f8f679b7e 100644 --- a/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h +++ b/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h @@ -39,11 +39,8 @@ #ifndef SILABS_CLUSTER_CLIENT_API #define SILABS_CLUSTER_CLIENT_API - // This is generated client API - - /** * @addtogroup command Application Framework command interface Reference * This document describes the ZCL command interface used by the Ember @@ -59,17 +56,9 @@ * @param attributeIds uint8_t* * @param attributeIdsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReadAttributes(clusterId, \ - attributeIds, \ - attributeIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_COMMAND_ID, \ - "b", \ - attributeIds, \ - attributeIdsLen); - +#define emberAfFillCommandGlobalServerToClientReadAttributes(clusterId, attributeIds, attributeIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_READ_ATTRIBUTES_COMMAND_ID, "b", attributeIds, attributeIdsLen); /** @brief Command description for ReadAttributes * @@ -78,17 +67,9 @@ * @param attributeIds uint8_t* * @param attributeIdsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReadAttributes(clusterId, \ - attributeIds, \ - attributeIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_COMMAND_ID, \ - "b", \ - attributeIds, \ - attributeIdsLen); - +#define emberAfFillCommandGlobalClientToServerReadAttributes(clusterId, attributeIds, attributeIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_READ_ATTRIBUTES_COMMAND_ID, "b", attributeIds, attributeIdsLen); /** @brief Command description for ReadAttributesResponse * @@ -97,17 +78,11 @@ * @param readAttributeStatusRecords uint8_t* * @param readAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReadAttributesResponse(clusterId, \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "b", \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen); - +#define emberAfFillCommandGlobalServerToClientReadAttributesResponse(clusterId, readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", readAttributeStatusRecords, \ + readAttributeStatusRecordsLen); /** @brief Command description for ReadAttributesResponse * @@ -116,17 +91,11 @@ * @param readAttributeStatusRecords uint8_t* * @param readAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReadAttributesResponse(clusterId, \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "b", \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen); - +#define emberAfFillCommandGlobalClientToServerReadAttributesResponse(clusterId, readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", readAttributeStatusRecords, \ + readAttributeStatusRecordsLen); /** @brief Command description for WriteAttributes * @@ -135,17 +104,9 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributes(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributes(clusterId, writeAttributeRecords, writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for WriteAttributes * @@ -154,17 +115,9 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributes(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerWriteAttributes(clusterId, writeAttributeRecords, writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for WriteAttributesUndivided * @@ -173,17 +126,9 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributesUndivided(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributesUndivided(clusterId, writeAttributeRecords, writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for WriteAttributesUndivided * @@ -192,17 +137,9 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributesUndivided(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerWriteAttributesUndivided(clusterId, writeAttributeRecords, writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for WriteAttributesResponse * @@ -211,17 +148,11 @@ * @param writeAttributeStatusRecords uint8_t* * @param writeAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributesResponse(clusterId, \ - writeAttributeStatusRecords, \ - writeAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "b", \ - writeAttributeStatusRecords, \ - writeAttributeStatusRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributesResponse(clusterId, writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen); /** @brief Command description for WriteAttributesResponse * @@ -230,17 +161,11 @@ * @param writeAttributeStatusRecords uint8_t* * @param writeAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributesResponse(clusterId, \ - writeAttributeStatusRecords, \ - writeAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "b", \ - writeAttributeStatusRecords, \ - writeAttributeStatusRecordsLen); - +#define emberAfFillCommandGlobalClientToServerWriteAttributesResponse(clusterId, writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID, "b", writeAttributeStatusRecords, \ + writeAttributeStatusRecordsLen); /** @brief Command description for WriteAttributesNoResponse * @@ -249,17 +174,10 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributesNoResponse(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributesNoResponse(clusterId, writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for WriteAttributesNoResponse * @@ -268,17 +186,10 @@ * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributesNoResponse(clusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, \ - "b", \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerWriteAttributesNoResponse(clusterId, writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID, "b", writeAttributeRecords, writeAttributeRecordsLen); /** @brief Command description for ConfigureReporting * @@ -287,17 +198,10 @@ * @param configureReportingRecords uint8_t* * @param configureReportingRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientConfigureReporting(clusterId, \ - configureReportingRecords, \ - configureReportingRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_CONFIGURE_REPORTING_COMMAND_ID, \ - "b", \ - configureReportingRecords, \ - configureReportingRecordsLen); - +#define emberAfFillCommandGlobalServerToClientConfigureReporting(clusterId, configureReportingRecords, \ + configureReportingRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_CONFIGURE_REPORTING_COMMAND_ID, "b", configureReportingRecords, configureReportingRecordsLen); /** @brief Command description for ConfigureReporting * @@ -306,17 +210,10 @@ * @param configureReportingRecords uint8_t* * @param configureReportingRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerConfigureReporting(clusterId, \ - configureReportingRecords, \ - configureReportingRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_CONFIGURE_REPORTING_COMMAND_ID, \ - "b", \ - configureReportingRecords, \ - configureReportingRecordsLen); - +#define emberAfFillCommandGlobalClientToServerConfigureReporting(clusterId, configureReportingRecords, \ + configureReportingRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_CONFIGURE_REPORTING_COMMAND_ID, "b", configureReportingRecords, configureReportingRecordsLen); /** @brief Command description for ConfigureReportingResponse * @@ -325,17 +222,11 @@ * @param configureReportingStatusRecords uint8_t* * @param configureReportingStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientConfigureReportingResponse(clusterId, \ - configureReportingStatusRecords, \ - configureReportingStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, \ - "b", \ - configureReportingStatusRecords, \ - configureReportingStatusRecordsLen); - +#define emberAfFillCommandGlobalServerToClientConfigureReportingResponse(clusterId, configureReportingStatusRecords, \ + configureReportingStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, "b", configureReportingStatusRecords, \ + configureReportingStatusRecordsLen); /** @brief Command description for ConfigureReportingResponse * @@ -344,17 +235,11 @@ * @param configureReportingStatusRecords uint8_t* * @param configureReportingStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerConfigureReportingResponse(clusterId, \ - configureReportingStatusRecords, \ - configureReportingStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, \ - "b", \ - configureReportingStatusRecords, \ - configureReportingStatusRecordsLen); - +#define emberAfFillCommandGlobalClientToServerConfigureReportingResponse(clusterId, configureReportingStatusRecords, \ + configureReportingStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID, "b", configureReportingStatusRecords, \ + configureReportingStatusRecordsLen); /** @brief Command description for ReadReportingConfiguration * @@ -363,17 +248,11 @@ * @param readReportingConfigurationAttributeRecords uint8_t* * @param readReportingConfigurationAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReadReportingConfiguration(clusterId, \ - readReportingConfigurationAttributeRecords, \ - readReportingConfigurationAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, \ - "b", \ - readReportingConfigurationAttributeRecords, \ - readReportingConfigurationAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientReadReportingConfiguration(clusterId, readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, "b", readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen); /** @brief Command description for ReadReportingConfiguration * @@ -382,17 +261,11 @@ * @param readReportingConfigurationAttributeRecords uint8_t* * @param readReportingConfigurationAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReadReportingConfiguration(clusterId, \ - readReportingConfigurationAttributeRecords, \ - readReportingConfigurationAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, \ - "b", \ - readReportingConfigurationAttributeRecords, \ - readReportingConfigurationAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerReadReportingConfiguration(clusterId, readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID, "b", readReportingConfigurationAttributeRecords, \ + readReportingConfigurationAttributeRecordsLen); /** @brief Command description for ReadReportingConfigurationResponse * @@ -401,17 +274,11 @@ * @param readReportingConfigurationRecords uint8_t* * @param readReportingConfigurationRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReadReportingConfigurationResponse(clusterId, \ - readReportingConfigurationRecords, \ - readReportingConfigurationRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, \ - "b", \ - readReportingConfigurationRecords, \ - readReportingConfigurationRecordsLen); - +#define emberAfFillCommandGlobalServerToClientReadReportingConfigurationResponse(clusterId, readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, "b", readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen); /** @brief Command description for ReadReportingConfigurationResponse * @@ -420,17 +287,11 @@ * @param readReportingConfigurationRecords uint8_t* * @param readReportingConfigurationRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReadReportingConfigurationResponse(clusterId, \ - readReportingConfigurationRecords, \ - readReportingConfigurationRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, \ - "b", \ - readReportingConfigurationRecords, \ - readReportingConfigurationRecordsLen); - +#define emberAfFillCommandGlobalClientToServerReadReportingConfigurationResponse(clusterId, readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID, "b", readReportingConfigurationRecords, \ + readReportingConfigurationRecordsLen); /** @brief Command description for ReportAttributes * @@ -439,17 +300,9 @@ * @param reportAttributeRecords uint8_t* * @param reportAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReportAttributes(clusterId, \ - reportAttributeRecords, \ - reportAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_REPORT_ATTRIBUTES_COMMAND_ID, \ - "b", \ - reportAttributeRecords, \ - reportAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientReportAttributes(clusterId, reportAttributeRecords, reportAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_REPORT_ATTRIBUTES_COMMAND_ID, "b", reportAttributeRecords, reportAttributeRecordsLen); /** @brief Command description for ReportAttributes * @@ -458,17 +311,9 @@ * @param reportAttributeRecords uint8_t* * @param reportAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReportAttributes(clusterId, \ - reportAttributeRecords, \ - reportAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_REPORT_ATTRIBUTES_COMMAND_ID, \ - "b", \ - reportAttributeRecords, \ - reportAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerReportAttributes(clusterId, reportAttributeRecords, reportAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_REPORT_ATTRIBUTES_COMMAND_ID, "b", reportAttributeRecords, reportAttributeRecordsLen); /** @brief Command description for DefaultResponse * @@ -477,17 +322,9 @@ * @param commandId uint8_t * @param status uint8_t */ -#define emberAfFillCommandGlobalServerToClientDefaultResponse(clusterId, \ - commandId, \ - status) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DEFAULT_RESPONSE_COMMAND_ID, \ - "uu", \ - commandId, \ - status); - +#define emberAfFillCommandGlobalServerToClientDefaultResponse(clusterId, commandId, status) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DEFAULT_RESPONSE_COMMAND_ID, "uu", commandId, status); /** @brief Command description for DefaultResponse * @@ -496,17 +333,9 @@ * @param commandId uint8_t * @param status uint8_t */ -#define emberAfFillCommandGlobalClientToServerDefaultResponse(clusterId, \ - commandId, \ - status) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DEFAULT_RESPONSE_COMMAND_ID, \ - "uu", \ - commandId, \ - status); - +#define emberAfFillCommandGlobalClientToServerDefaultResponse(clusterId, commandId, status) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DEFAULT_RESPONSE_COMMAND_ID, "uu", commandId, status); /** @brief Command description for DiscoverAttributes * @@ -515,17 +344,9 @@ * @param startId uint16_t * @param maxAttributeIds uint8_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverAttributes(clusterId, \ - startId, \ - maxAttributeIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, \ - "vu", \ - startId, \ - maxAttributeIds); - +#define emberAfFillCommandGlobalServerToClientDiscoverAttributes(clusterId, startId, maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, "vu", startId, maxAttributeIds); /** @brief Command description for DiscoverAttributes * @@ -534,17 +355,9 @@ * @param startId uint16_t * @param maxAttributeIds uint8_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverAttributes(clusterId, \ - startId, \ - maxAttributeIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, \ - "vu", \ - startId, \ - maxAttributeIds); - +#define emberAfFillCommandGlobalClientToServerDiscoverAttributes(clusterId, startId, maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID, "vu", startId, maxAttributeIds); /** @brief Command description for DiscoverAttributesResponse * @@ -554,19 +367,11 @@ * @param discoverAttributesInfoRecords uint8_t* * @param discoverAttributesInfoRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverAttributesResponse(clusterId, \ - discoveryComplete, \ - discoverAttributesInfoRecords, \ - discoverAttributesInfoRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - discoverAttributesInfoRecords, \ - discoverAttributesInfoRecordsLen); - +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesResponse( \ + clusterId, discoveryComplete, discoverAttributesInfoRecords, discoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, "ub", discoveryComplete, discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen); /** @brief Command description for DiscoverAttributesResponse * @@ -576,19 +381,11 @@ * @param discoverAttributesInfoRecords uint8_t* * @param discoverAttributesInfoRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverAttributesResponse(clusterId, \ - discoveryComplete, \ - discoverAttributesInfoRecords, \ - discoverAttributesInfoRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - discoverAttributesInfoRecords, \ - discoverAttributesInfoRecordsLen); - +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesResponse( \ + clusterId, discoveryComplete, discoverAttributesInfoRecords, discoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID, "ub", discoveryComplete, discoverAttributesInfoRecords, \ + discoverAttributesInfoRecordsLen); /** @brief Command description for ReadAttributesStructured * @@ -597,17 +394,11 @@ * @param readStructuredAttributeRecords uint8_t* * @param readStructuredAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientReadAttributesStructured(clusterId, \ - readStructuredAttributeRecords, \ - readStructuredAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ - "b", \ - readStructuredAttributeRecords, \ - readStructuredAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientReadAttributesStructured(clusterId, readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen); /** @brief Command description for ReadAttributesStructured * @@ -616,17 +407,11 @@ * @param readStructuredAttributeRecords uint8_t* * @param readStructuredAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerReadAttributesStructured(clusterId, \ - readStructuredAttributeRecords, \ - readStructuredAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ - "b", \ - readStructuredAttributeRecords, \ - readStructuredAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerReadAttributesStructured(clusterId, readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", readStructuredAttributeRecords, \ + readStructuredAttributeRecordsLen); /** @brief Command description for WriteAttributesStructured * @@ -635,17 +420,11 @@ * @param writeStructuredAttributeRecords uint8_t* * @param writeStructuredAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributesStructured(clusterId, \ - writeStructuredAttributeRecords, \ - writeStructuredAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ - "b", \ - writeStructuredAttributeRecords, \ - writeStructuredAttributeRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributesStructured(clusterId, writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen); /** @brief Command description for WriteAttributesStructured * @@ -654,17 +433,11 @@ * @param writeStructuredAttributeRecords uint8_t* * @param writeStructuredAttributeRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributesStructured(clusterId, \ - writeStructuredAttributeRecords, \ - writeStructuredAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, \ - "b", \ - writeStructuredAttributeRecords, \ - writeStructuredAttributeRecordsLen); - +#define emberAfFillCommandGlobalClientToServerWriteAttributesStructured(clusterId, writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID, "b", writeStructuredAttributeRecords, \ + writeStructuredAttributeRecordsLen); /** @brief Command description for WriteAttributesStructuredResponse * @@ -673,17 +446,11 @@ * @param writeStructuredAttributeStatusRecords uint8_t* * @param writeStructuredAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientWriteAttributesStructuredResponse(clusterId, \ - writeStructuredAttributeStatusRecords, \ - writeStructuredAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, \ - "b", \ - writeStructuredAttributeStatusRecords, \ - writeStructuredAttributeStatusRecordsLen); - +#define emberAfFillCommandGlobalServerToClientWriteAttributesStructuredResponse(clusterId, writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, "b", writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen); /** @brief Command description for WriteAttributesStructuredResponse * @@ -692,57 +459,38 @@ * @param writeStructuredAttributeStatusRecords uint8_t* * @param writeStructuredAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerWriteAttributesStructuredResponse(clusterId, \ - writeStructuredAttributeStatusRecords, \ - writeStructuredAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, \ - "b", \ - writeStructuredAttributeStatusRecords, \ - writeStructuredAttributeStatusRecordsLen); +#define emberAfFillCommandGlobalClientToServerWriteAttributesStructuredResponse(clusterId, writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID, "b", writeStructuredAttributeStatusRecords, \ + writeStructuredAttributeStatusRecordsLen); - -/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or manufacturer specific commands. +/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or + * manufacturer specific commands. * * Command: DiscoverCommandsReceived * @param clusterId EmberAfClusterId * @param startCommandId uint8_t * @param maxCommandIds uint8_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceived(clusterId, \ - startCommandId, \ - maxCommandIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, \ - "uu", \ - startCommandId, \ - maxCommandIds); - +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceived(clusterId, startCommandId, maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, "uu", startCommandId, maxCommandIds); -/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or manufacturer specific commands. +/** @brief This command may be used to discover all commands processed (received) by this cluster, including optional or + * manufacturer specific commands. * * Command: DiscoverCommandsReceived * @param clusterId EmberAfClusterId * @param startCommandId uint8_t * @param maxCommandIds uint8_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceived(clusterId, \ - startCommandId, \ - maxCommandIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, \ - "uu", \ - startCommandId, \ - maxCommandIds); +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceived(clusterId, startCommandId, maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID, "uu", startCommandId, maxCommandIds); - -/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used to discover which commands a particular cluster can process. +/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used + * to discover which commands a particular cluster can process. * * Command: DiscoverCommandsReceivedResponse * @param clusterId EmberAfClusterId @@ -750,21 +498,14 @@ * @param commandIds uint8_t* * @param commandIdsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceivedResponse(clusterId, \ - discoveryComplete, \ - commandIds, \ - commandIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - commandIds, \ - commandIdsLen); - +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsReceivedResponse(clusterId, discoveryComplete, commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, commandIds, \ + commandIdsLen); -/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used to discover which commands a particular cluster can process. +/** @brief The discover commands received response command is sent in response to a discover commands received command, and is used + * to discover which commands a particular cluster can process. * * Command: DiscoverCommandsReceivedResponse * @param clusterId EmberAfClusterId @@ -772,59 +513,38 @@ * @param commandIds uint8_t* * @param commandIdsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceivedResponse(clusterId, \ - discoveryComplete, \ - commandIds, \ - commandIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - commandIds, \ - commandIdsLen); +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsReceivedResponse(clusterId, discoveryComplete, commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, commandIds, \ + commandIdsLen); - -/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or manufacturer specific commands. +/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or + * manufacturer specific commands. * * Command: DiscoverCommandsGenerated * @param clusterId EmberAfClusterId * @param startCommandId uint8_t * @param maxCommandIds uint8_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGenerated(clusterId, \ - startCommandId, \ - maxCommandIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, \ - "uu", \ - startCommandId, \ - maxCommandIds); - +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGenerated(clusterId, startCommandId, maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, "uu", startCommandId, maxCommandIds); -/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or manufacturer specific commands. +/** @brief This command may be used to discover all commands which may be generated (sent) by the cluster, including optional or + * manufacturer specific commands. * * Command: DiscoverCommandsGenerated * @param clusterId EmberAfClusterId * @param startCommandId uint8_t * @param maxCommandIds uint8_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGenerated(clusterId, \ - startCommandId, \ - maxCommandIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, \ - "uu", \ - startCommandId, \ - maxCommandIds); +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGenerated(clusterId, startCommandId, maxCommandIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID, "uu", startCommandId, maxCommandIds); - -/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to discover which commands a particular cluster supports. +/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to + * discover which commands a particular cluster supports. * * Command: DiscoverCommandsGeneratedResponse * @param clusterId EmberAfClusterId @@ -832,21 +552,14 @@ * @param commandIds uint8_t* * @param commandIdsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGeneratedResponse(clusterId, \ - discoveryComplete, \ - commandIds, \ - commandIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - commandIds, \ - commandIdsLen); - +#define emberAfFillCommandGlobalServerToClientDiscoverCommandsGeneratedResponse(clusterId, discoveryComplete, commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, commandIds, \ + commandIdsLen); -/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to discover which commands a particular cluster supports. +/** @brief The discover client commands response command is sent in response to a discover client commands command, and is used to + * discover which commands a particular cluster supports. * * Command: DiscoverCommandsGeneratedResponse * @param clusterId EmberAfClusterId @@ -854,59 +567,38 @@ * @param commandIds uint8_t* * @param commandIdsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGeneratedResponse(clusterId, \ - discoveryComplete, \ - commandIds, \ - commandIdsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - commandIds, \ - commandIdsLen); +#define emberAfFillCommandGlobalClientToServerDiscoverCommandsGeneratedResponse(clusterId, discoveryComplete, commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, commandIds, \ + commandIdsLen); - -/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute is readable, writeable or reportable. +/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute + * is readable, writeable or reportable. * * Command: DiscoverAttributesExtended * @param clusterId EmberAfClusterId * @param startId uint16_t * @param maxAttributeIds uint8_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtended(clusterId, \ - startId, \ - maxAttributeIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, \ - "vu", \ - startId, \ - maxAttributeIds); - +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtended(clusterId, startId, maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, "vu", startId, maxAttributeIds); -/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute is readable, writeable or reportable. +/** @brief This command is similar to the discover attributes command, but also includes a field to indicate whether the attribute + * is readable, writeable or reportable. * * Command: DiscoverAttributesExtended * @param clusterId EmberAfClusterId * @param startId uint16_t * @param maxAttributeIds uint8_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtended(clusterId, \ - startId, \ - maxAttributeIds) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, \ - "vu", \ - startId, \ - maxAttributeIds); +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtended(clusterId, startId, maxAttributeIds) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID, "vu", startId, maxAttributeIds); - -/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are readable, writable or reportable. +/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are + * readable, writable or reportable. * * Command: DiscoverAttributesExtendedResponse * @param clusterId EmberAfClusterId @@ -914,21 +606,14 @@ * @param extendedDiscoverAttributesInfoRecords uint8_t* * @param extendedDiscoverAttributesInfoRecordsLen uint16_t */ -#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtendedResponse(clusterId, \ - discoveryComplete, \ - extendedDiscoverAttributesInfoRecords, \ - extendedDiscoverAttributesInfoRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - extendedDiscoverAttributesInfoRecords, \ - extendedDiscoverAttributesInfoRecordsLen); - +#define emberAfFillCommandGlobalServerToClientDiscoverAttributesExtendedResponse( \ + clusterId, discoveryComplete, extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen); -/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are readable, writable or reportable. +/** @brief This command is sent in response to a discover attribute extended command and is used to determine if attributes are + * readable, writable or reportable. * * Command: DiscoverAttributesExtendedResponse * @param clusterId EmberAfClusterId @@ -936,91 +621,60 @@ * @param extendedDiscoverAttributesInfoRecords uint8_t* * @param extendedDiscoverAttributesInfoRecordsLen uint16_t */ -#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtendedResponse(clusterId, \ - discoveryComplete, \ - extendedDiscoverAttributesInfoRecords, \ - extendedDiscoverAttributesInfoRecordsLen) \ - emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - clusterId, \ - ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - extendedDiscoverAttributesInfoRecords, \ - extendedDiscoverAttributesInfoRecordsLen); - +#define emberAfFillCommandGlobalClientToServerDiscoverAttributesExtendedResponse( \ + clusterId, discoveryComplete, extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen) \ + emberAfFillExternalBuffer((ZCL_GLOBAL_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), clusterId, \ + ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, \ + extendedDiscoverAttributesInfoRecords, extendedDiscoverAttributesInfoRecordsLen); /** @} END Global Commands */ - - /** @name Basic Commands */ // @{ /** @brief Command that resets all attribute values to factory default. * - * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. - * Command: ResetToFactoryDefaults + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, + * and enabling a device. Command: ResetToFactoryDefaults */ -#define emberAfFillCommandBasicClusterResetToFactoryDefaults() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BASIC_CLUSTER_ID, \ - ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandBasicClusterResetToFactoryDefaults() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BASIC_CLUSTER_ID, \ + ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID, ""); /** @brief This command gets locales supported. * - * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. - * Command: GetLocalesSupported + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, + * and enabling a device. Command: GetLocalesSupported * @param startLocale uint8_t* * @param maxLocalesRequested uint8_t */ -#define emberAfFillCommandBasicClusterGetLocalesSupported(startLocale, \ - maxLocalesRequested) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BASIC_CLUSTER_ID, \ - ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID, \ - "su", \ - startLocale, \ - maxLocalesRequested); +#define emberAfFillCommandBasicClusterGetLocalesSupported(startLocale, maxLocalesRequested) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BASIC_CLUSTER_ID, \ + ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID, "su", startLocale, maxLocalesRequested); - -/** @brief The locales supported response command is sent in response to a get locales supported command, and is used to discover which locales the device supports. +/** @brief The locales supported response command is sent in response to a get locales supported command, and is used to discover + * which locales the device supports. * - * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, and enabling a device. - * Command: GetLocalesSupportedResponse + * Cluster: Basic, Attributes for determining basic information about a device, setting user device information such as location, + * and enabling a device. Command: GetLocalesSupportedResponse * @param discoveryComplete uint8_t * @param localeSupported uint8_t* * @param localeSupportedLen uint16_t */ -#define emberAfFillCommandBasicClusterGetLocalesSupportedResponse(discoveryComplete, \ - localeSupported, \ - localeSupportedLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_BASIC_CLUSTER_ID, \ - ZCL_GET_LOCALES_SUPPORTED_RESPONSE_COMMAND_ID, \ - "ub", \ - discoveryComplete, \ - localeSupported, \ - localeSupportedLen); - +#define emberAfFillCommandBasicClusterGetLocalesSupportedResponse(discoveryComplete, localeSupported, localeSupportedLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_BASIC_CLUSTER_ID, \ + ZCL_GET_LOCALES_SUPPORTED_RESPONSE_COMMAND_ID, "ub", discoveryComplete, localeSupported, \ + localeSupportedLen); /** @} END Basic Commands */ - /** @name Power Configuration Commands */ // @{ /** @} END Power Configuration Commands */ - /** @name Device Temperature Configuration Commands */ // @{ /** @} END Device Temperature Configuration Commands */ - /** @name Identify Commands */ // @{ /** @brief Command description for Identify @@ -1029,27 +683,18 @@ * Command: Identify * @param identifyTime uint16_t */ -#define emberAfFillCommandIdentifyClusterIdentify(identifyTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_IDENTIFY_COMMAND_ID, \ - "v", \ - identifyTime); - +#define emberAfFillCommandIdentifyClusterIdentify(identifyTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_COMMAND_ID, "v", identifyTime); /** @brief Command description for IdentifyQuery * * Cluster: Identify, Attributes and commands for putting a device into Identification mode (e.g. flashing a light). * Command: IdentifyQuery */ -#define emberAfFillCommandIdentifyClusterIdentifyQuery() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_IDENTIFY_QUERY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIdentifyClusterIdentifyQuery() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_QUERY_COMMAND_ID, ""); /** @brief Invoke EZMode on an Identify Server * @@ -1057,14 +702,9 @@ * Command: EZModeInvoke * @param action uint8_t */ -#define emberAfFillCommandIdentifyClusterEZModeInvoke(action) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_E_Z_MODE_INVOKE_COMMAND_ID, \ - "u", \ - action); - +#define emberAfFillCommandIdentifyClusterEZModeInvoke(action) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_E_Z_MODE_INVOKE_COMMAND_ID, "u", action); /** @brief Update Commission State on the server device. * @@ -1073,16 +713,9 @@ * @param action uint8_t * @param commissionStateMask uint8_t */ -#define emberAfFillCommandIdentifyClusterUpdateCommissionState(action, \ - commissionStateMask) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID, \ - "uu", \ - action, \ - commissionStateMask); - +#define emberAfFillCommandIdentifyClusterUpdateCommissionState(action, commissionStateMask) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID, "uu", action, commissionStateMask); /** @brief Command description for IdentifyQueryResponse * @@ -1090,14 +723,9 @@ * Command: IdentifyQueryResponse * @param timeout uint16_t */ -#define emberAfFillCommandIdentifyClusterIdentifyQueryResponse(timeout) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID, \ - "v", \ - timeout); - +#define emberAfFillCommandIdentifyClusterIdentifyQueryResponse(timeout) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID, "v", timeout); /** @brief Command description for TriggerEffect * @@ -1106,20 +734,12 @@ * @param effectId uint8_t * @param effectVariant uint8_t */ -#define emberAfFillCommandIdentifyClusterTriggerEffect(effectId, \ - effectVariant) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IDENTIFY_CLUSTER_ID, \ - ZCL_TRIGGER_EFFECT_COMMAND_ID, \ - "uu", \ - effectId, \ - effectVariant); - +#define emberAfFillCommandIdentifyClusterTriggerEffect(effectId, effectVariant) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IDENTIFY_CLUSTER_ID, \ + ZCL_TRIGGER_EFFECT_COMMAND_ID, "uu", effectId, effectVariant); /** @} END Identify Commands */ - /** @name Groups Commands */ // @{ /** @brief Command description for AddGroup @@ -1129,16 +749,9 @@ * @param groupId uint16_t * @param groupName uint8_t* */ -#define emberAfFillCommandGroupsClusterAddGroup(groupId, \ - groupName) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_ADD_GROUP_COMMAND_ID, \ - "vs", \ - groupId, \ - groupName); - +#define emberAfFillCommandGroupsClusterAddGroup(groupId, groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_COMMAND_ID, "vs", groupId, groupName); /** @brief Command description for ViewGroup * @@ -1146,14 +759,9 @@ * Command: ViewGroup * @param groupId uint16_t */ -#define emberAfFillCommandGroupsClusterViewGroup(groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_VIEW_GROUP_COMMAND_ID, \ - "v", \ - groupId); - +#define emberAfFillCommandGroupsClusterViewGroup(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_VIEW_GROUP_COMMAND_ID, "v", groupId); /** @brief Command description for GetGroupMembership * @@ -1163,18 +771,9 @@ * @param groupList uint8_t* * @param groupListLen uint16_t */ -#define emberAfFillCommandGroupsClusterGetGroupMembership(groupCount, \ - groupList, \ - groupListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID, \ - "ub", \ - groupCount, \ - groupList, \ - groupListLen); - +#define emberAfFillCommandGroupsClusterGetGroupMembership(groupCount, groupList, groupListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID, "ub", groupCount, groupList, groupListLen); /** @brief Command description for RemoveGroup * @@ -1182,27 +781,18 @@ * Command: RemoveGroup * @param groupId uint16_t */ -#define emberAfFillCommandGroupsClusterRemoveGroup(groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_REMOVE_GROUP_COMMAND_ID, \ - "v", \ - groupId); - +#define emberAfFillCommandGroupsClusterRemoveGroup(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_GROUP_COMMAND_ID, "v", groupId); /** @brief Command description for RemoveAllGroups * * Cluster: Groups, Attributes and commands for group configuration and manipulation. * Command: RemoveAllGroups */ -#define emberAfFillCommandGroupsClusterRemoveAllGroups() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_REMOVE_ALL_GROUPS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGroupsClusterRemoveAllGroups() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_ALL_GROUPS_COMMAND_ID, ""); /** @brief Command description for AddGroupIfIdentifying * @@ -1211,16 +801,9 @@ * @param groupId uint16_t * @param groupName uint8_t* */ -#define emberAfFillCommandGroupsClusterAddGroupIfIdentifying(groupId, \ - groupName) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID, \ - "vs", \ - groupId, \ - groupName); - +#define emberAfFillCommandGroupsClusterAddGroupIfIdentifying(groupId, groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID, "vs", groupId, groupName); /** @brief Command description for AddGroupResponse * @@ -1229,16 +812,9 @@ * @param status uint8_t * @param groupId uint16_t */ -#define emberAfFillCommandGroupsClusterAddGroupResponse(status, \ - groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_ADD_GROUP_RESPONSE_COMMAND_ID, \ - "uv", \ - status, \ - groupId); - +#define emberAfFillCommandGroupsClusterAddGroupResponse(status, groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_ADD_GROUP_RESPONSE_COMMAND_ID, "uv", status, groupId); /** @brief Command description for ViewGroupResponse * @@ -1248,18 +824,9 @@ * @param groupId uint16_t * @param groupName uint8_t* */ -#define emberAfFillCommandGroupsClusterViewGroupResponse(status, \ - groupId, \ - groupName) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID, \ - "uvs", \ - status, \ - groupId, \ - groupName); - +#define emberAfFillCommandGroupsClusterViewGroupResponse(status, groupId, groupName) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID, "uvs", status, groupId, groupName); /** @brief Command description for GetGroupMembershipResponse * @@ -1270,20 +837,9 @@ * @param groupList uint8_t* * @param groupListLen uint16_t */ -#define emberAfFillCommandGroupsClusterGetGroupMembershipResponse(capacity, \ - groupCount, \ - groupList, \ - groupListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID, \ - "uub", \ - capacity, \ - groupCount, \ - groupList, \ - groupListLen); - +#define emberAfFillCommandGroupsClusterGetGroupMembershipResponse(capacity, groupCount, groupList, groupListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID, "uub", capacity, groupCount, groupList, groupListLen); /** @brief Command description for RemoveGroupResponse * @@ -1292,23 +848,16 @@ * @param status uint8_t * @param groupId uint16_t */ -#define emberAfFillCommandGroupsClusterRemoveGroupResponse(status, \ - groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GROUPS_CLUSTER_ID, \ - ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID, \ - "uv", \ - status, \ - groupId); - +#define emberAfFillCommandGroupsClusterRemoveGroupResponse(status, groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GROUPS_CLUSTER_ID, \ + ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID, "uv", status, groupId); /** @} END Groups Commands */ - /** @name Scenes Commands */ // @{ -/** @brief Add a scene to the scene table. Extension field sets are supported, and are inputed as arrays of the form [[cluster ID] [length] [value0...n] ...] +/** @brief Add a scene to the scene table. Extension field sets are supported, and are inputed as arrays of the form [[cluster ID] + * [length] [value0...n] ...] * * Cluster: Scenes, Attributes and commands for scene configuration and manipulation. * Command: AddScene @@ -1319,24 +868,11 @@ * @param extensionFieldSets uint8_t* * @param extensionFieldSetsLen uint16_t */ -#define emberAfFillCommandScenesClusterAddScene(groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ADD_SCENE_COMMAND_ID, \ - "vuvsb", \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen); - +#define emberAfFillCommandScenesClusterAddScene(groupId, sceneId, transitionTime, sceneName, extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ADD_SCENE_COMMAND_ID, "vuvsb", groupId, sceneId, transitionTime, sceneName, extensionFieldSets, \ + extensionFieldSetsLen); /** @brief Command description for ViewScene * @@ -1345,16 +881,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterViewScene(groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_VIEW_SCENE_COMMAND_ID, \ - "vu", \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterViewScene(groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_VIEW_SCENE_COMMAND_ID, "vu", groupId, sceneId); /** @brief Command description for RemoveScene * @@ -1363,16 +892,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterRemoveScene(groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_REMOVE_SCENE_COMMAND_ID, \ - "vu", \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterRemoveScene(groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_SCENE_COMMAND_ID, "vu", groupId, sceneId); /** @brief Command description for RemoveAllScenes * @@ -1380,14 +902,9 @@ * Command: RemoveAllScenes * @param groupId uint16_t */ -#define emberAfFillCommandScenesClusterRemoveAllScenes(groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_REMOVE_ALL_SCENES_COMMAND_ID, \ - "v", \ - groupId); - +#define emberAfFillCommandScenesClusterRemoveAllScenes(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_ALL_SCENES_COMMAND_ID, "v", groupId); /** @brief Command description for StoreScene * @@ -1396,16 +913,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterStoreScene(groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_STORE_SCENE_COMMAND_ID, \ - "vu", \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterStoreScene(groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_STORE_SCENE_COMMAND_ID, "vu", groupId, sceneId); /** @brief Command description for RecallScene * @@ -1415,18 +925,9 @@ * @param sceneId uint8_t * @param transitionTime uint16_t */ -#define emberAfFillCommandScenesClusterRecallScene(groupId, \ - sceneId, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_RECALL_SCENE_COMMAND_ID, \ - "vuv", \ - groupId, \ - sceneId, \ - transitionTime); - +#define emberAfFillCommandScenesClusterRecallScene(groupId, sceneId, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_RECALL_SCENE_COMMAND_ID, "vuv", groupId, sceneId, transitionTime); /** @brief Command description for GetSceneMembership * @@ -1434,14 +935,9 @@ * Command: GetSceneMembership * @param groupId uint16_t */ -#define emberAfFillCommandScenesClusterGetSceneMembership(groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID, \ - "v", \ - groupId); - +#define emberAfFillCommandScenesClusterGetSceneMembership(groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID, "v", groupId); /** @brief Command description for AddSceneResponse * @@ -1451,18 +947,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterAddSceneResponse(status, \ - groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ADD_SCENE_RESPONSE_COMMAND_ID, \ - "uvu", \ - status, \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterAddSceneResponse(status, groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ADD_SCENE_RESPONSE_COMMAND_ID, "uvu", status, groupId, sceneId); /** @brief Command description for ViewSceneResponse * @@ -1476,26 +963,11 @@ * @param extensionFieldSets uint8_t* * @param extensionFieldSetsLen uint16_t */ -#define emberAfFillCommandScenesClusterViewSceneResponse(status, \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID, \ - "uvuvsb", \ - status, \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen); - +#define emberAfFillCommandScenesClusterViewSceneResponse(status, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID, "uvuvsb", status, groupId, sceneId, transitionTime, sceneName, \ + extensionFieldSets, extensionFieldSetsLen); /** @brief Command description for RemoveSceneResponse * @@ -1505,18 +977,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterRemoveSceneResponse(status, \ - groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID, \ - "uvu", \ - status, \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterRemoveSceneResponse(status, groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID, "uvu", status, groupId, sceneId); /** @brief Command description for RemoveAllScenesResponse * @@ -1525,16 +988,9 @@ * @param status uint8_t * @param groupId uint16_t */ -#define emberAfFillCommandScenesClusterRemoveAllScenesResponse(status, \ - groupId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID, \ - "uv", \ - status, \ - groupId); - +#define emberAfFillCommandScenesClusterRemoveAllScenesResponse(status, groupId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID, "uv", status, groupId); /** @brief Command description for StoreSceneResponse * @@ -1544,18 +1000,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterStoreSceneResponse(status, \ - groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_STORE_SCENE_RESPONSE_COMMAND_ID, \ - "uvu", \ - status, \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterStoreSceneResponse(status, groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_STORE_SCENE_RESPONSE_COMMAND_ID, "uvu", status, groupId, sceneId); /** @brief Command description for GetSceneMembershipResponse * @@ -1568,24 +1015,10 @@ * @param sceneList uint8_t* * @param sceneListLen uint16_t */ -#define emberAfFillCommandScenesClusterGetSceneMembershipResponse(status, \ - capacity, \ - groupId, \ - sceneCount, \ - sceneList, \ - sceneListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID, \ - "uuvub", \ - status, \ - capacity, \ - groupId, \ - sceneCount, \ - sceneList, \ - sceneListLen); - +#define emberAfFillCommandScenesClusterGetSceneMembershipResponse(status, capacity, groupId, sceneCount, sceneList, sceneListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID, "uuvub", status, capacity, groupId, sceneCount, \ + sceneList, sceneListLen); /** @brief Command description for EnhancedAddScene * @@ -1598,24 +1031,11 @@ * @param extensionFieldSets uint8_t* * @param extensionFieldSetsLen uint16_t */ -#define emberAfFillCommandScenesClusterEnhancedAddScene(groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ENHANCED_ADD_SCENE_COMMAND_ID, \ - "vuvsb", \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen); - +#define emberAfFillCommandScenesClusterEnhancedAddScene(groupId, sceneId, transitionTime, sceneName, extensionFieldSets, \ + extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_ADD_SCENE_COMMAND_ID, "vuvsb", groupId, sceneId, transitionTime, sceneName, \ + extensionFieldSets, extensionFieldSetsLen); /** @brief Command description for EnhancedViewScene * @@ -1624,16 +1044,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterEnhancedViewScene(groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID, \ - "vu", \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterEnhancedViewScene(groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID, "vu", groupId, sceneId); /** @brief Command description for CopyScene * @@ -1645,22 +1058,9 @@ * @param groupIdTo uint16_t * @param sceneIdTo uint8_t */ -#define emberAfFillCommandScenesClusterCopyScene(mode, \ - groupIdFrom, \ - sceneIdFrom, \ - groupIdTo, \ - sceneIdTo) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_COPY_SCENE_COMMAND_ID, \ - "uvuvu", \ - mode, \ - groupIdFrom, \ - sceneIdFrom, \ - groupIdTo, \ - sceneIdTo); - +#define emberAfFillCommandScenesClusterCopyScene(mode, groupIdFrom, sceneIdFrom, groupIdTo, sceneIdTo) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SCENES_CLUSTER_ID, \ + ZCL_COPY_SCENE_COMMAND_ID, "uvuvu", mode, groupIdFrom, sceneIdFrom, groupIdTo, sceneIdTo); /** @brief Command description for EnhancedAddSceneResponse * @@ -1670,18 +1070,9 @@ * @param groupId uint16_t * @param sceneId uint8_t */ -#define emberAfFillCommandScenesClusterEnhancedAddSceneResponse(status, \ - groupId, \ - sceneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID, \ - "uvu", \ - status, \ - groupId, \ - sceneId); - +#define emberAfFillCommandScenesClusterEnhancedAddSceneResponse(status, groupId, sceneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID, "uvu", status, groupId, sceneId); /** @brief Command description for EnhancedViewSceneResponse * @@ -1695,26 +1086,11 @@ * @param extensionFieldSets uint8_t* * @param extensionFieldSetsLen uint16_t */ -#define emberAfFillCommandScenesClusterEnhancedViewSceneResponse(status, \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID, \ - "uvuvsb", \ - status, \ - groupId, \ - sceneId, \ - transitionTime, \ - sceneName, \ - extensionFieldSets, \ - extensionFieldSetsLen); - +#define emberAfFillCommandScenesClusterEnhancedViewSceneResponse(status, groupId, sceneId, transitionTime, sceneName, \ + extensionFieldSets, extensionFieldSetsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID, "uvuvsb", status, groupId, sceneId, transitionTime, \ + sceneName, extensionFieldSets, extensionFieldSetsLen); /** @brief Command description for CopySceneResponse * @@ -1724,22 +1100,12 @@ * @param groupIdFrom uint16_t * @param sceneIdFrom uint8_t */ -#define emberAfFillCommandScenesClusterCopySceneResponse(status, \ - groupIdFrom, \ - sceneIdFrom) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SCENES_CLUSTER_ID, \ - ZCL_COPY_SCENE_RESPONSE_COMMAND_ID, \ - "uvu", \ - status, \ - groupIdFrom, \ - sceneIdFrom); - +#define emberAfFillCommandScenesClusterCopySceneResponse(status, groupIdFrom, sceneIdFrom) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SCENES_CLUSTER_ID, \ + ZCL_COPY_SCENE_RESPONSE_COMMAND_ID, "uvu", status, groupIdFrom, sceneIdFrom); /** @} END Scenes Commands */ - /** @name On/off Commands */ // @{ /** @brief Command description for Off @@ -1747,39 +1113,27 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: Off */ -#define emberAfFillCommandOnOffClusterOff() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_OFF_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterOff() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_OFF_COMMAND_ID, ""); /** @brief Command description for On * * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: On */ -#define emberAfFillCommandOnOffClusterOn() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_ON_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterOn() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_COMMAND_ID, ""); /** @brief Command description for Toggle * * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: Toggle */ -#define emberAfFillCommandOnOffClusterToggle() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_TOGGLE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterToggle() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_TOGGLE_COMMAND_ID, ""); /** @brief Command description for OffWithEffect * @@ -1788,29 +1142,18 @@ * @param effectId uint8_t * @param effectVariant uint8_t */ -#define emberAfFillCommandOnOffClusterOffWithEffect(effectId, \ - effectVariant) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_OFF_WITH_EFFECT_COMMAND_ID, \ - "uu", \ - effectId, \ - effectVariant); - +#define emberAfFillCommandOnOffClusterOffWithEffect(effectId, effectVariant) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_OFF_WITH_EFFECT_COMMAND_ID, "uu", effectId, effectVariant); /** @brief Command description for OnWithRecallGlobalScene * * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: OnWithRecallGlobalScene */ -#define emberAfFillCommandOnOffClusterOnWithRecallGlobalScene() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterOnWithRecallGlobalScene() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID, ""); /** @brief Command description for OnWithTimedOff * @@ -1820,18 +1163,9 @@ * @param onTime uint16_t * @param offWaitTime uint16_t */ -#define emberAfFillCommandOnOffClusterOnWithTimedOff(onOffControl, \ - onTime, \ - offWaitTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - ZCL_ON_WITH_TIMED_OFF_COMMAND_ID, \ - "uvv", \ - onOffControl, \ - onTime, \ - offWaitTime); - +#define emberAfFillCommandOnOffClusterOnWithTimedOff(onOffControl, onTime, offWaitTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ON_OFF_CLUSTER_ID, \ + ZCL_ON_WITH_TIMED_OFF_COMMAND_ID, "uvv", onOffControl, onTime, offWaitTime); /** @brief Client command that turns the device off with a transition given by the transition time in the Ember Sample transition time attribute. @@ -1839,15 +1173,10 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: SampleMfgSpecificOffWithTransition */ -#define emberAfFillCommandOnOffClusterSampleMfgSpecificOffWithTransition() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - 0x1002, \ - ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOffWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, 0x1002, ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID, ""); /** @brief Client command that turns the device on with a transition given by the transition time in the Ember Sample transition time attribute. @@ -1855,15 +1184,10 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: SampleMfgSpecificOnWithTransition */ -#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - 0x1002, \ - ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, 0x1002, ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID, ""); /** @brief Client command that toggles the device with a transition given by the transition time in the Ember Sample transition time attribute. @@ -1871,15 +1195,10 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: SampleMfgSpecificToggleWithTransition */ -#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - 0x1002, \ - ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, 0x1002, ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID, ""); /** @brief Client command that turns the device on with a transition given by the transition time in the Ember Sample transition time attribute. @@ -1887,15 +1206,10 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: SampleMfgSpecificOnWithTransition2 */ -#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition2() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - 0x1049, \ - ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterSampleMfgSpecificOnWithTransition2() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, 0x1049, ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID, ""); /** @brief Client command that toggles the device with a transition given by the transition time in the Ember Sample transition time attribute. @@ -1903,192 +1217,115 @@ * Cluster: On/off, Attributes and commands for switching devices between 'On' and 'Off' states. * Command: SampleMfgSpecificToggleWithTransition2 */ -#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition2() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ON_OFF_CLUSTER_ID, \ - 0x1049, \ - ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION2_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOnOffClusterSampleMfgSpecificToggleWithTransition2() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ON_OFF_CLUSTER_ID, 0x1049, ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION2_COMMAND_ID, ""); /** @} END On/off Commands */ - /** @name On/off Switch Configuration Commands */ // @{ /** @} END On/off Switch Configuration Commands */ - /** @name Level Control Commands */ // @{ /** @brief Command description for MoveToLevel * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: MoveToLevel + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: MoveToLevel * @param level uint8_t * @param transitionTime uint16_t * @param optionMask uint8_t * @param optionOverride uint8_t */ -#define emberAfFillCommandLevelControlClusterMoveToLevel(level, \ - transitionTime, \ - optionMask, \ - optionOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_LEVEL_COMMAND_ID, \ - "uvuu", \ - level, \ - transitionTime, \ - optionMask, \ - optionOverride); - +#define emberAfFillCommandLevelControlClusterMoveToLevel(level, transitionTime, optionMask, optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_LEVEL_COMMAND_ID, "uvuu", level, transitionTime, optionMask, optionOverride); /** @brief Command description for Move * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: Move + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: Move * @param moveMode uint8_t * @param rate uint8_t * @param optionMask uint8_t * @param optionOverride uint8_t */ -#define emberAfFillCommandLevelControlClusterMove(moveMode, \ - rate, \ - optionMask, \ - optionOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_COMMAND_ID, \ - "uuuu", \ - moveMode, \ - rate, \ - optionMask, \ - optionOverride); - +#define emberAfFillCommandLevelControlClusterMove(moveMode, rate, optionMask, optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COMMAND_ID, "uuuu", moveMode, rate, optionMask, optionOverride); /** @brief Command description for Step * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: Step + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: Step * @param stepMode uint8_t * @param stepSize uint8_t * @param transitionTime uint16_t * @param optionMask uint8_t * @param optionOverride uint8_t */ -#define emberAfFillCommandLevelControlClusterStep(stepMode, \ - stepSize, \ - transitionTime, \ - optionMask, \ - optionOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_STEP_COMMAND_ID, \ - "uuvuu", \ - stepMode, \ - stepSize, \ - transitionTime, \ - optionMask, \ - optionOverride); - +#define emberAfFillCommandLevelControlClusterStep(stepMode, stepSize, transitionTime, optionMask, optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COMMAND_ID, "uuvuu", stepMode, stepSize, transitionTime, optionMask, optionOverride); /** @brief Command description for Stop * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: Stop + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: Stop * @param optionMask uint8_t * @param optionOverride uint8_t */ -#define emberAfFillCommandLevelControlClusterStop(optionMask, \ - optionOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_STOP_COMMAND_ID, \ - "uu", \ - optionMask, \ - optionOverride); - +#define emberAfFillCommandLevelControlClusterStop(optionMask, optionOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STOP_COMMAND_ID, "uu", optionMask, optionOverride); /** @brief Command description for MoveToLevelWithOnOff * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: MoveToLevelWithOnOff + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: MoveToLevelWithOnOff * @param level uint8_t * @param transitionTime uint16_t */ -#define emberAfFillCommandLevelControlClusterMoveToLevelWithOnOff(level, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID, \ - "uv", \ - level, \ - transitionTime); - +#define emberAfFillCommandLevelControlClusterMoveToLevelWithOnOff(level, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID, "uv", level, transitionTime); /** @brief Command description for MoveWithOnOff * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: MoveWithOnOff + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: MoveWithOnOff * @param moveMode uint8_t * @param rate uint8_t */ -#define emberAfFillCommandLevelControlClusterMoveWithOnOff(moveMode, \ - rate) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_WITH_ON_OFF_COMMAND_ID, \ - "uu", \ - moveMode, \ - rate); - +#define emberAfFillCommandLevelControlClusterMoveWithOnOff(moveMode, rate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_WITH_ON_OFF_COMMAND_ID, "uu", moveMode, rate); /** @brief Command description for StepWithOnOff * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: StepWithOnOff + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: StepWithOnOff * @param stepMode uint8_t * @param stepSize uint8_t * @param transitionTime uint16_t */ -#define emberAfFillCommandLevelControlClusterStepWithOnOff(stepMode, \ - stepSize, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_STEP_WITH_ON_OFF_COMMAND_ID, \ - "uuv", \ - stepMode, \ - stepSize, \ - transitionTime); - +#define emberAfFillCommandLevelControlClusterStepWithOnOff(stepMode, stepSize, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STEP_WITH_ON_OFF_COMMAND_ID, "uuv", stepMode, stepSize, transitionTime); /** @brief Command description for StopWithOnOff * - * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully 'Off.' - * Command: StopWithOnOff + * Cluster: Level Control, Attributes and commands for controlling devices that can be set to a level between fully 'On' and fully + * 'Off.' Command: StopWithOnOff */ -#define emberAfFillCommandLevelControlClusterStopWithOnOff() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_LEVEL_CONTROL_CLUSTER_ID, \ - ZCL_STOP_WITH_ON_OFF_COMMAND_ID, \ - ""); - +#define emberAfFillCommandLevelControlClusterStopWithOnOff() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_LEVEL_CONTROL_CLUSTER_ID, \ + ZCL_STOP_WITH_ON_OFF_COMMAND_ID, ""); /** @} END Level Control Commands */ - /** @name Alarms Commands */ // @{ /** @brief Command description for ResetAlarm @@ -2098,55 +1335,36 @@ * @param alarmCode uint8_t * @param clusterId uint16_t */ -#define emberAfFillCommandAlarmClusterResetAlarm(alarmCode, \ - clusterId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_RESET_ALARM_COMMAND_ID, \ - "uv", \ - alarmCode, \ - clusterId); - +#define emberAfFillCommandAlarmClusterResetAlarm(alarmCode, clusterId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALARM_COMMAND_ID, "uv", alarmCode, clusterId); /** @brief Command description for ResetAllAlarms * * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. * Command: ResetAllAlarms */ -#define emberAfFillCommandAlarmClusterResetAllAlarms() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_RESET_ALL_ALARMS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandAlarmClusterResetAllAlarms() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALL_ALARMS_COMMAND_ID, ""); /** @brief Command description for GetAlarm * * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. * Command: GetAlarm */ -#define emberAfFillCommandAlarmClusterGetAlarm() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_GET_ALARM_COMMAND_ID, \ - ""); - +#define emberAfFillCommandAlarmClusterGetAlarm() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ALARM_CLUSTER_ID, \ + ZCL_GET_ALARM_COMMAND_ID, ""); /** @brief Command description for ResetAlarmLog * * Cluster: Alarms, Attributes and commands for sending notifications and configuring alarm functionality. * Command: ResetAlarmLog */ -#define emberAfFillCommandAlarmClusterResetAlarmLog() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_RESET_ALARM_LOG_COMMAND_ID, \ - ""); - +#define emberAfFillCommandAlarmClusterResetAlarmLog() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_ALARM_CLUSTER_ID, \ + ZCL_RESET_ALARM_LOG_COMMAND_ID, ""); /** @brief Command description for Alarm * @@ -2155,16 +1373,9 @@ * @param alarmCode uint8_t * @param clusterId uint16_t */ -#define emberAfFillCommandAlarmClusterAlarm(alarmCode, \ - clusterId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_ALARM_COMMAND_ID, \ - "uv", \ - alarmCode, \ - clusterId); - +#define emberAfFillCommandAlarmClusterAlarm(alarmCode, clusterId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_ALARM_CLUSTER_ID, \ + ZCL_ALARM_COMMAND_ID, "uv", alarmCode, clusterId); /** @brief Command description for GetAlarmResponse * @@ -2175,125 +1386,75 @@ * @param clusterId uint16_t * @param timeStamp uint32_t */ -#define emberAfFillCommandAlarmClusterGetAlarmResponse(status, \ - alarmCode, \ - clusterId, \ - timeStamp) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ALARM_CLUSTER_ID, \ - ZCL_GET_ALARM_RESPONSE_COMMAND_ID, \ - "uuvw", \ - status, \ - alarmCode, \ - clusterId, \ - timeStamp); - +#define emberAfFillCommandAlarmClusterGetAlarmResponse(status, alarmCode, clusterId, timeStamp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_ALARM_CLUSTER_ID, \ + ZCL_GET_ALARM_RESPONSE_COMMAND_ID, "uuvw", status, alarmCode, clusterId, timeStamp); /** @} END Alarms Commands */ - /** @name Time Commands */ // @{ /** @} END Time Commands */ - /** @name RSSI Location Commands */ // @{ /** @brief Command description for SetAbsoluteLocation * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: SetAbsoluteLocation + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: SetAbsoluteLocation * @param coordinate1 int16_t * @param coordinate2 int16_t * @param coordinate3 int16_t * @param power int16_t * @param pathLossExponent uint16_t */ -#define emberAfFillCommandRssiLocationClusterSetAbsoluteLocation(coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID, \ - "vvvvv", \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent); - +#define emberAfFillCommandRssiLocationClusterSetAbsoluteLocation(coordinate1, coordinate2, coordinate3, power, pathLossExponent) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID, "vvvvv", coordinate1, coordinate2, coordinate3, power, \ + pathLossExponent); /** @brief Command description for SetDeviceConfiguration * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: SetDeviceConfiguration + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: SetDeviceConfiguration * @param power int16_t * @param pathLossExponent uint16_t * @param calculationPeriod uint16_t * @param numberRssiMeasurements uint8_t * @param reportingPeriod uint16_t */ -#define emberAfFillCommandRssiLocationClusterSetDeviceConfiguration(power, \ - pathLossExponent, \ - calculationPeriod, \ - numberRssiMeasurements, \ - reportingPeriod) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID, \ - "vvvuv", \ - power, \ - pathLossExponent, \ - calculationPeriod, \ - numberRssiMeasurements, \ - reportingPeriod); - +#define emberAfFillCommandRssiLocationClusterSetDeviceConfiguration(power, pathLossExponent, calculationPeriod, \ + numberRssiMeasurements, reportingPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID, "vvvuv", power, pathLossExponent, calculationPeriod, \ + numberRssiMeasurements, reportingPeriod); /** @brief Command description for GetDeviceConfiguration * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: GetDeviceConfiguration + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: GetDeviceConfiguration * @param targetAddress uint8_t* */ -#define emberAfFillCommandRssiLocationClusterGetDeviceConfiguration(targetAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID, \ - "8", \ - targetAddress); - +#define emberAfFillCommandRssiLocationClusterGetDeviceConfiguration(targetAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID, "8", targetAddress); /** @brief Command description for GetLocationData * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: GetLocationData + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: GetLocationData * @param flags uint8_t * @param numberResponses uint8_t * @param targetAddress uint8_t* */ -#define emberAfFillCommandRssiLocationClusterGetLocationData(flags, \ - numberResponses, \ - targetAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_GET_LOCATION_DATA_COMMAND_ID, \ - "uu8", \ - flags, \ - numberResponses, \ - targetAddress); - +#define emberAfFillCommandRssiLocationClusterGetLocationData(flags, numberResponses, targetAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_GET_LOCATION_DATA_COMMAND_ID, "uu8", flags, numberResponses, targetAddress); /** @brief Command description for RssiResponse * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: RssiResponse + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: RssiResponse * @param replyingDevice uint8_t* * @param coordinate1 int16_t * @param coordinate2 int16_t @@ -2301,74 +1462,42 @@ * @param rssi int8_t * @param numberRssiMeasurements uint8_t */ -#define emberAfFillCommandRssiLocationClusterRssiResponse(replyingDevice, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - rssi, \ - numberRssiMeasurements) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_RSSI_RESPONSE_COMMAND_ID, \ - "8vvvuu", \ - replyingDevice, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - rssi, \ - numberRssiMeasurements); - +#define emberAfFillCommandRssiLocationClusterRssiResponse(replyingDevice, coordinate1, coordinate2, coordinate3, rssi, \ + numberRssiMeasurements) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_RESPONSE_COMMAND_ID, "8vvvuu", replyingDevice, coordinate1, coordinate2, coordinate3, rssi, \ + numberRssiMeasurements); /** @brief Command description for SendPings * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: SendPings + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: SendPings * @param targetAddress uint8_t* * @param numberRssiMeasurements uint8_t * @param calculationPeriod uint16_t */ -#define emberAfFillCommandRssiLocationClusterSendPings(targetAddress, \ - numberRssiMeasurements, \ - calculationPeriod) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_SEND_PINGS_COMMAND_ID, \ - "8uv", \ - targetAddress, \ - numberRssiMeasurements, \ - calculationPeriod); - +#define emberAfFillCommandRssiLocationClusterSendPings(targetAddress, numberRssiMeasurements, calculationPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_SEND_PINGS_COMMAND_ID, "8uv", targetAddress, numberRssiMeasurements, calculationPeriod); /** @brief Command description for AnchorNodeAnnounce * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: AnchorNodeAnnounce + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: AnchorNodeAnnounce * @param anchorNodeIeeeAddress uint8_t* * @param coordinate1 int16_t * @param coordinate2 int16_t * @param coordinate3 int16_t */ -#define emberAfFillCommandRssiLocationClusterAnchorNodeAnnounce(anchorNodeIeeeAddress, \ - coordinate1, \ - coordinate2, \ - coordinate3) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID, \ - "8vvv", \ - anchorNodeIeeeAddress, \ - coordinate1, \ - coordinate2, \ - coordinate3); - +#define emberAfFillCommandRssiLocationClusterAnchorNodeAnnounce(anchorNodeIeeeAddress, coordinate1, coordinate2, coordinate3) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID, "8vvv", anchorNodeIeeeAddress, coordinate1, coordinate2, \ + coordinate3); /** @brief Command description for DeviceConfigurationResponse * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: DeviceConfigurationResponse + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: DeviceConfigurationResponse * @param status uint8_t * @param power int16_t * @param pathLossExponent uint16_t @@ -2376,29 +1505,16 @@ * @param numberRssiMeasurements uint8_t * @param reportingPeriod uint16_t */ -#define emberAfFillCommandRssiLocationClusterDeviceConfigurationResponse(status, \ - power, \ - pathLossExponent, \ - calculationPeriod, \ - numberRssiMeasurements, \ - reportingPeriod) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID, \ - "uvvvuv", \ - status, \ - power, \ - pathLossExponent, \ - calculationPeriod, \ - numberRssiMeasurements, \ - reportingPeriod); - +#define emberAfFillCommandRssiLocationClusterDeviceConfigurationResponse(status, power, pathLossExponent, calculationPeriod, \ + numberRssiMeasurements, reportingPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID, "uvvvuv", status, power, pathLossExponent, \ + calculationPeriod, numberRssiMeasurements, reportingPeriod); /** @brief Command description for LocationDataResponse * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: LocationDataResponse + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: LocationDataResponse * @param status uint8_t * @param locationType uint8_t * @param coordinate1 int16_t @@ -2410,37 +1526,17 @@ * @param qualityMeasure uint8_t * @param locationAge uint16_t */ -#define emberAfFillCommandRssiLocationClusterLocationDataResponse(status, \ - locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent, \ - locationMethod, \ - qualityMeasure, \ - locationAge) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID, \ - "uuvvvvvuuv", \ - status, \ - locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent, \ - locationMethod, \ - qualityMeasure, \ - locationAge); - +#define emberAfFillCommandRssiLocationClusterLocationDataResponse(status, locationType, coordinate1, coordinate2, coordinate3, \ + power, pathLossExponent, locationMethod, qualityMeasure, \ + locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID, "uuvvvvvuuv", status, locationType, coordinate1, coordinate2, \ + coordinate3, power, pathLossExponent, locationMethod, qualityMeasure, locationAge); /** @brief Command description for LocationDataNotification * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: LocationDataNotification + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: LocationDataNotification * @param locationType uint8_t * @param coordinate1 int16_t * @param coordinate2 int16_t @@ -2451,35 +1547,16 @@ * @param qualityMeasure uint8_t * @param locationAge uint16_t */ -#define emberAfFillCommandRssiLocationClusterLocationDataNotification(locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent, \ - locationMethod, \ - qualityMeasure, \ - locationAge) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID, \ - "uvvvvvuuv", \ - locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - power, \ - pathLossExponent, \ - locationMethod, \ - qualityMeasure, \ - locationAge); - +#define emberAfFillCommandRssiLocationClusterLocationDataNotification( \ + locationType, coordinate1, coordinate2, coordinate3, power, pathLossExponent, locationMethod, qualityMeasure, locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID, "uvvvvvuuv", locationType, coordinate1, coordinate2, \ + coordinate3, power, pathLossExponent, locationMethod, qualityMeasure, locationAge); /** @brief Command description for CompactLocationDataNotification * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: CompactLocationDataNotification + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: CompactLocationDataNotification * @param locationType uint8_t * @param coordinate1 int16_t * @param coordinate2 int16_t @@ -2487,100 +1564,61 @@ * @param qualityMeasure uint8_t * @param locationAge uint16_t */ -#define emberAfFillCommandRssiLocationClusterCompactLocationDataNotification(locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - qualityMeasure, \ - locationAge) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_COMPACT_LOCATION_DATA_NOTIFICATION_COMMAND_ID, \ - "uvvvuv", \ - locationType, \ - coordinate1, \ - coordinate2, \ - coordinate3, \ - qualityMeasure, \ - locationAge); - +#define emberAfFillCommandRssiLocationClusterCompactLocationDataNotification(locationType, coordinate1, coordinate2, coordinate3, \ + qualityMeasure, locationAge) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_COMPACT_LOCATION_DATA_NOTIFICATION_COMMAND_ID, "uvvvuv", locationType, coordinate1, coordinate2, \ + coordinate3, qualityMeasure, locationAge); /** @brief Command description for RssiPing * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: RssiPing + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: RssiPing * @param locationType uint8_t */ -#define emberAfFillCommandRssiLocationClusterRssiPing(locationType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_RSSI_PING_COMMAND_ID, \ - "u", \ - locationType); - +#define emberAfFillCommandRssiLocationClusterRssiPing(locationType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_PING_COMMAND_ID, "u", locationType); /** @brief Command description for RssiRequest * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: RssiRequest + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: RssiRequest */ -#define emberAfFillCommandRssiLocationClusterRssiRequest() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_RSSI_REQUEST_COMMAND_ID, \ - ""); - +#define emberAfFillCommandRssiLocationClusterRssiRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_RSSI_REQUEST_COMMAND_ID, ""); /** @brief Command description for ReportRssiMeasurements * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: ReportRssiMeasurements + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: ReportRssiMeasurements * @param measuringDevice uint8_t* * @param neighbors uint8_t * @param neighborsInfo uint8_t* * @param neighborsInfoLen uint16_t */ -#define emberAfFillCommandRssiLocationClusterReportRssiMeasurements(measuringDevice, \ - neighbors, \ - neighborsInfo, \ - neighborsInfoLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID, \ - "8ub", \ - measuringDevice, \ - neighbors, \ - neighborsInfo, \ - neighborsInfoLen); - +#define emberAfFillCommandRssiLocationClusterReportRssiMeasurements(measuringDevice, neighbors, neighborsInfo, neighborsInfoLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID, "8ub", measuringDevice, neighbors, neighborsInfo, \ + neighborsInfoLen); /** @brief Command description for RequestOwnLocation * - * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters among devices. - * Command: RequestOwnLocation + * Cluster: RSSI Location, Attributes and commands that provide a means for exchanging location information and channel parameters + * among devices. Command: RequestOwnLocation * @param blindNode uint8_t* */ -#define emberAfFillCommandRssiLocationClusterRequestOwnLocation(blindNode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_RSSI_LOCATION_CLUSTER_ID, \ - ZCL_REQUEST_OWN_LOCATION_COMMAND_ID, \ - "8", \ - blindNode); - +#define emberAfFillCommandRssiLocationClusterRequestOwnLocation(blindNode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_RSSI_LOCATION_CLUSTER_ID, \ + ZCL_REQUEST_OWN_LOCATION_COMMAND_ID, "8", blindNode); /** @} END RSSI Location Commands */ - /** @name Binary Input (Basic) Commands */ // @{ /** @} END Binary Input (Basic) Commands */ - /** @name Commissioning Commands */ // @{ /** @brief Command description for RestartDevice @@ -2591,18 +1629,9 @@ * @param delay uint8_t * @param jitter uint8_t */ -#define emberAfFillCommandCommissioningClusterRestartDevice(options, \ - delay, \ - jitter) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESTART_DEVICE_COMMAND_ID, \ - "uuu", \ - options, \ - delay, \ - jitter); - +#define emberAfFillCommandCommissioningClusterRestartDevice(options, delay, jitter) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTART_DEVICE_COMMAND_ID, "uuu", options, delay, jitter); /** @brief Command description for SaveStartupParameters * @@ -2611,16 +1640,9 @@ * @param options uint8_t * @param index uint8_t */ -#define emberAfFillCommandCommissioningClusterSaveStartupParameters(options, \ - index) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID, \ - "uu", \ - options, \ - index); - +#define emberAfFillCommandCommissioningClusterSaveStartupParameters(options, index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID, "uu", options, index); /** @brief Command description for RestoreStartupParameters * @@ -2629,16 +1651,9 @@ * @param options uint8_t * @param index uint8_t */ -#define emberAfFillCommandCommissioningClusterRestoreStartupParameters(options, \ - index) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID, \ - "uu", \ - options, \ - index); - +#define emberAfFillCommandCommissioningClusterRestoreStartupParameters(options, index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID, "uu", options, index); /** @brief Command description for ResetStartupParameters * @@ -2647,16 +1662,9 @@ * @param options uint8_t * @param index uint8_t */ -#define emberAfFillCommandCommissioningClusterResetStartupParameters(options, \ - index) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID, \ - "uu", \ - options, \ - index); - +#define emberAfFillCommandCommissioningClusterResetStartupParameters(options, index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID, "uu", options, index); /** @brief Command description for RestartDeviceResponse * @@ -2664,14 +1672,9 @@ * Command: RestartDeviceResponse * @param status uint8_t */ -#define emberAfFillCommandCommissioningClusterRestartDeviceResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandCommissioningClusterRestartDeviceResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID, "u", status); /** @brief Command description for SaveStartupParametersResponse * @@ -2679,14 +1682,9 @@ * Command: SaveStartupParametersResponse * @param status uint8_t */ -#define emberAfFillCommandCommissioningClusterSaveStartupParametersResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandCommissioningClusterSaveStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, "u", status); /** @brief Command description for RestoreStartupParametersResponse * @@ -2694,14 +1692,9 @@ * Command: RestoreStartupParametersResponse * @param status uint8_t */ -#define emberAfFillCommandCommissioningClusterRestoreStartupParametersResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESTORE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandCommissioningClusterRestoreStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESTORE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, "u", status); /** @brief Command description for ResetStartupParametersResponse * @@ -2709,215 +1702,143 @@ * Command: ResetStartupParametersResponse * @param status uint8_t */ -#define emberAfFillCommandCommissioningClusterResetStartupParametersResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandCommissioningClusterResetStartupParametersResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_COMMISSIONING_CLUSTER_ID, \ + ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID, "u", status); /** @} END Commissioning Commands */ - /** @name Partition Commands */ // @{ /** @brief The TransferPartitionedFrame command is used to send a partitioned frame to another Partition cluster. * - * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. - * Command: TransferPartitionedFrame + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee + * devices. Command: TransferPartitionedFrame * @param fragmentationOptions uint8_t * @param partitionedIndicatorAndFrame uint8_t* * @param partitionedIndicatorAndFrameLen uint16_t */ -#define emberAfFillCommandPartitionClusterTransferPartitionedFrame(fragmentationOptions, \ - partitionedIndicatorAndFrame, \ - partitionedIndicatorAndFrameLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PARTITION_CLUSTER_ID, \ - ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID, \ - "ub", \ - fragmentationOptions, \ - partitionedIndicatorAndFrame, \ - partitionedIndicatorAndFrameLen); - +#define emberAfFillCommandPartitionClusterTransferPartitionedFrame(fragmentationOptions, partitionedIndicatorAndFrame, \ + partitionedIndicatorAndFrameLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PARTITION_CLUSTER_ID, \ + ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID, "ub", fragmentationOptions, partitionedIndicatorAndFrame, \ + partitionedIndicatorAndFrameLen); -/** @brief The ReadHandshakeParam command is used in order to read the appropriate set of parameters for each transaction to be performed by the Partition Cluster. +/** @brief The ReadHandshakeParam command is used in order to read the appropriate set of parameters for each transaction to be + * performed by the Partition Cluster. * - * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. - * Command: ReadHandshakeParam + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee + * devices. Command: ReadHandshakeParam * @param partitionedClusterId uint16_t * @param attributeList uint8_t* * @param attributeListLen uint16_t */ -#define emberAfFillCommandPartitionClusterReadHandshakeParam(partitionedClusterId, \ - attributeList, \ - attributeListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PARTITION_CLUSTER_ID, \ - ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID, \ - "vb", \ - partitionedClusterId, \ - attributeList, \ - attributeListLen); +#define emberAfFillCommandPartitionClusterReadHandshakeParam(partitionedClusterId, attributeList, attributeListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PARTITION_CLUSTER_ID, \ + ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID, "vb", partitionedClusterId, attributeList, attributeListLen); - -/** @brief The WriteHandshakeParam command is used during the handshake phase in order to write the appropriate parameters for each transaction to be performed by the Partition Cluster. +/** @brief The WriteHandshakeParam command is used during the handshake phase in order to write the appropriate parameters for each + * transaction to be performed by the Partition Cluster. * - * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. - * Command: WriteHandshakeParam + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee + * devices. Command: WriteHandshakeParam * @param partitionedClusterId uint16_t * @param writeAttributeRecords uint8_t* * @param writeAttributeRecordsLen uint16_t */ -#define emberAfFillCommandPartitionClusterWriteHandshakeParam(partitionedClusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PARTITION_CLUSTER_ID, \ - ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID, \ - "vb", \ - partitionedClusterId, \ - writeAttributeRecords, \ - writeAttributeRecordsLen); - +#define emberAfFillCommandPartitionClusterWriteHandshakeParam(partitionedClusterId, writeAttributeRecords, \ + writeAttributeRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PARTITION_CLUSTER_ID, \ + ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID, "vb", partitionedClusterId, writeAttributeRecords, \ + writeAttributeRecordsLen); /** @brief MultipleACK command. * - * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. - * Command: MultipleAck + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee + * devices. Command: MultipleAck * @param ackOptions uint8_t * @param firstFrameIdAndNackList uint8_t* * @param firstFrameIdAndNackListLen uint16_t */ -#define emberAfFillCommandPartitionClusterMultipleAck(ackOptions, \ - firstFrameIdAndNackList, \ - firstFrameIdAndNackListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PARTITION_CLUSTER_ID, \ - ZCL_MULTIPLE_ACK_COMMAND_ID, \ - "ub", \ - ackOptions, \ - firstFrameIdAndNackList, \ - firstFrameIdAndNackListLen); +#define emberAfFillCommandPartitionClusterMultipleAck(ackOptions, firstFrameIdAndNackList, firstFrameIdAndNackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PARTITION_CLUSTER_ID, \ + ZCL_MULTIPLE_ACK_COMMAND_ID, "ub", ackOptions, firstFrameIdAndNackList, firstFrameIdAndNackListLen); - -/** @brief The ReadHandshakeParamResponse command is used in order to response to the corresponding ReadHandshakeParam command in order to communicate the appropriate set of parameters configured for each transaction to be performed by the Partition Cluster. +/** @brief The ReadHandshakeParamResponse command is used in order to response to the corresponding ReadHandshakeParam command in + * order to communicate the appropriate set of parameters configured for each transaction to be performed by the Partition Cluster. * - * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee devices. - * Command: ReadHandshakeParamResponse + * Cluster: Partition, Commands and attributes for enabling partitioning of large frame to be carried from other clusters of ZigBee + * devices. Command: ReadHandshakeParamResponse * @param partitionedClusterId uint16_t * @param readAttributeStatusRecords uint8_t* * @param readAttributeStatusRecordsLen uint16_t */ -#define emberAfFillCommandPartitionClusterReadHandshakeParamResponse(partitionedClusterId, \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PARTITION_CLUSTER_ID, \ - ZCL_READ_HANDSHAKE_PARAM_RESPONSE_COMMAND_ID, \ - "vb", \ - partitionedClusterId, \ - readAttributeStatusRecords, \ - readAttributeStatusRecordsLen); - +#define emberAfFillCommandPartitionClusterReadHandshakeParamResponse(partitionedClusterId, readAttributeStatusRecords, \ + readAttributeStatusRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PARTITION_CLUSTER_ID, \ + ZCL_READ_HANDSHAKE_PARAM_RESPONSE_COMMAND_ID, "vb", partitionedClusterId, \ + readAttributeStatusRecords, readAttributeStatusRecordsLen); /** @} END Partition Commands */ - /** @name Over the Air Bootloading Commands */ // @{ -/** @brief This command is generated when the upgrade server wishes to notify the clients of the available OTA upgrade image. The command can be sent as unicast which provides a way for the server to force the upgrade on the client. The command can also be sent as broadcast or multicast to certain class of clients (for example, the ones that have matching manufacturing and device ids). +/** @brief This command is generated when the upgrade server wishes to notify the clients of the available OTA upgrade image. The + * command can be sent as unicast which provides a way for the server to force the upgrade on the client. The command can also be + * sent as broadcast or multicast to certain class of clients (for example, the ones that have matching manufacturing and device + * ids). * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: ImageNotify + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: ImageNotify * @param payloadType uint8_t * @param queryJitter uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t * @param newFileVersion uint32_t */ -#define emberAfFillCommandOtaBootloadClusterImageNotify(payloadType, \ - queryJitter, \ - manufacturerId, \ - imageType, \ - newFileVersion) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_IMAGE_NOTIFY_COMMAND_ID, \ - "uuvvw", \ - payloadType, \ - queryJitter, \ - manufacturerId, \ - imageType, \ - newFileVersion); - - -/** @brief This command is generated upon receipt of an Image Notify command to indicate that the client is looking for the next firmware image to upgrade to. The client may also choose to send the command periodically to the server. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: QueryNextImageRequest +#define emberAfFillCommandOtaBootloadClusterImageNotify(payloadType, queryJitter, manufacturerId, imageType, newFileVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_NOTIFY_COMMAND_ID, "uuvvw", payloadType, queryJitter, manufacturerId, imageType, \ + newFileVersion); + +/** @brief This command is generated upon receipt of an Image Notify command to indicate that the client is looking for the next + * firmware image to upgrade to. The client may also choose to send the command periodically to the server. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: QueryNextImageRequest * @param fieldControl uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t * @param currentFileVersion uint32_t * @param hardwareVersion uint16_t */ -#define emberAfFillCommandOtaBootloadClusterQueryNextImageRequest(fieldControl, \ - manufacturerId, \ - imageType, \ - currentFileVersion, \ - hardwareVersion) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID, \ - "uvvwv", \ - fieldControl, \ - manufacturerId, \ - imageType, \ - currentFileVersion, \ - hardwareVersion); - - -/** @brief This command is generated upon receipt of an QueryNextImageRequest command to response whether the server has a valid OTA upgrade image for the client or not. If the server has the file, information regarding the file and OTA upgrade process will be included in the command. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: QueryNextImageResponse +#define emberAfFillCommandOtaBootloadClusterQueryNextImageRequest(fieldControl, manufacturerId, imageType, currentFileVersion, \ + hardwareVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID, "uvvwv", fieldControl, manufacturerId, imageType, \ + currentFileVersion, hardwareVersion); + +/** @brief This command is generated upon receipt of an QueryNextImageRequest command to response whether the server has a valid OTA + * upgrade image for the client or not. If the server has the file, information regarding the file and OTA upgrade process will be + * included in the command. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: QueryNextImageResponse * @param status uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t * @param fileVersion uint32_t * @param imageSize uint32_t */ -#define emberAfFillCommandOtaBootloadClusterQueryNextImageResponse(status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - imageSize) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID, \ - "uvvww", \ - status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - imageSize); - +#define emberAfFillCommandOtaBootloadClusterQueryNextImageResponse(status, manufacturerId, imageType, fileVersion, imageSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID, "uvvww", status, manufacturerId, imageType, fileVersion, \ + imageSize); /** @brief This command is generated by the client to request blocks of OTA upgrade file data. * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: ImageBlockRequest + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: ImageBlockRequest * @param fieldControl uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t @@ -2926,31 +1847,17 @@ * @param maxDataSize uint8_t * @param requestNodeAddress uint8_t* */ -#define emberAfFillCommandOtaBootloadClusterImageBlockRequest(fieldControl, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - maxDataSize, \ - requestNodeAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID, \ - "uvvwwu8", \ - fieldControl, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - maxDataSize, \ - requestNodeAddress); - - -/** @brief This command is generated by the client to request pages of OTA upgrade file data. A page would contain multiple blocks of data. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: ImagePageRequest +#define emberAfFillCommandOtaBootloadClusterImageBlockRequest(fieldControl, manufacturerId, imageType, fileVersion, fileOffset, \ + maxDataSize, requestNodeAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID, "uvvwwu8", fieldControl, manufacturerId, imageType, fileVersion, \ + fileOffset, maxDataSize, requestNodeAddress); + +/** @brief This command is generated by the client to request pages of OTA upgrade file data. A page would contain multiple blocks + * of data. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: ImagePageRequest * @param fieldControl uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t @@ -2961,35 +1868,18 @@ * @param responseSpacing uint16_t * @param requestNodeAddress uint8_t* */ -#define emberAfFillCommandOtaBootloadClusterImagePageRequest(fieldControl, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - maxDataSize, \ - pageSize, \ - responseSpacing, \ - requestNodeAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID, \ - "uvvwwuvv8", \ - fieldControl, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - maxDataSize, \ - pageSize, \ - responseSpacing, \ - requestNodeAddress); - - -/** @brief This command is generated by the server in response to the block or page request command. If the server has the data available, it will reply back with a SUCCESS status. For other error cases, it may reply with status WAIT_FOR_DATA (server does not have the data available yet) or ABORT (invalid requested parameters or other failure cases). - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: ImageBlockResponse +#define emberAfFillCommandOtaBootloadClusterImagePageRequest(fieldControl, manufacturerId, imageType, fileVersion, fileOffset, \ + maxDataSize, pageSize, responseSpacing, requestNodeAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID, "uvvwwuvv8", fieldControl, manufacturerId, imageType, \ + fileVersion, fileOffset, maxDataSize, pageSize, responseSpacing, requestNodeAddress); + +/** @brief This command is generated by the server in response to the block or page request command. If the server has the data + * available, it will reply back with a SUCCESS status. For other error cases, it may reply with status WAIT_FOR_DATA (server does + * not have the data available yet) or ABORT (invalid requested parameters or other failure cases). + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: ImageBlockResponse * @param status uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t @@ -2999,567 +1889,395 @@ * @param imageData uint8_t* * @param imageDataLen uint16_t */ -#define emberAfFillCommandOtaBootloadClusterImageBlockResponse(status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - dataSize, \ - imageData, \ - imageDataLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID, \ - "uvvwwub", \ - status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - fileOffset, \ - dataSize, \ - imageData, \ - imageDataLen); - - -/** @brief This command is generated by the client to notify the server of the end of the upgrade process. The process may end with success or error status. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: UpgradeEndRequest +#define emberAfFillCommandOtaBootloadClusterImageBlockResponse(status, manufacturerId, imageType, fileVersion, fileOffset, \ + dataSize, imageData, imageDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID, "uvvwwub", status, manufacturerId, imageType, fileVersion, \ + fileOffset, dataSize, imageData, imageDataLen); + +/** @brief This command is generated by the client to notify the server of the end of the upgrade process. The process may end with + * success or error status. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: UpgradeEndRequest * @param status uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t * @param fileVersion uint32_t */ -#define emberAfFillCommandOtaBootloadClusterUpgradeEndRequest(status, \ - manufacturerId, \ - imageType, \ - fileVersion) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_UPGRADE_END_REQUEST_COMMAND_ID, \ - "uvvw", \ - status, \ - manufacturerId, \ - imageType, \ - fileVersion); - - -/** @brief This command is generated by the server in response to the upgrade request in order to let the client know when to upgrade to running new firmware image. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: UpgradeEndResponse +#define emberAfFillCommandOtaBootloadClusterUpgradeEndRequest(status, manufacturerId, imageType, fileVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_UPGRADE_END_REQUEST_COMMAND_ID, "uvvw", status, manufacturerId, imageType, fileVersion); + +/** @brief This command is generated by the server in response to the upgrade request in order to let the client know when to + * upgrade to running new firmware image. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: UpgradeEndResponse * @param manufacturerId uint16_t * @param imageType uint16_t * @param fileVersion uint32_t * @param currentTime uint32_t * @param upgradeTime uint32_t */ -#define emberAfFillCommandOtaBootloadClusterUpgradeEndResponse(manufacturerId, \ - imageType, \ - fileVersion, \ - currentTime, \ - upgradeTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_UPGRADE_END_RESPONSE_COMMAND_ID, \ - "vvwww", \ - manufacturerId, \ - imageType, \ - fileVersion, \ - currentTime, \ - upgradeTime); - - -/** @brief This command is generated by the client to request a file that is specific to itself. The intention is to provide a way for the client to request non-OTA upgrade file. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: QuerySpecificFileRequest +#define emberAfFillCommandOtaBootloadClusterUpgradeEndResponse(manufacturerId, imageType, fileVersion, currentTime, upgradeTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_UPGRADE_END_RESPONSE_COMMAND_ID, "vvwww", manufacturerId, imageType, fileVersion, currentTime, \ + upgradeTime); + +/** @brief This command is generated by the client to request a file that is specific to itself. The intention is to provide a way + * for the client to request non-OTA upgrade file. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: QuerySpecificFileRequest * @param requestNodeAddress uint8_t* * @param manufacturerId uint16_t * @param imageType uint16_t * @param fileVersion uint32_t * @param currentZigbeeStackVersion uint16_t */ -#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileRequest(requestNodeAddress, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - currentZigbeeStackVersion) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID, \ - "8vvwv", \ - requestNodeAddress, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - currentZigbeeStackVersion); - - -/** @brief This command is generated upon receipt of an QuerySpecificFileRequest command to response whether the server has a valid file for the client or not. If the server has the file, information regarding the file and OTA process will be included in the command. - * - * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air bootloading. - * Command: QuerySpecificFileResponse +#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileRequest(requestNodeAddress, manufacturerId, imageType, fileVersion, \ + currentZigbeeStackVersion) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID, "8vvwv", requestNodeAddress, manufacturerId, imageType, \ + fileVersion, currentZigbeeStackVersion); + +/** @brief This command is generated upon receipt of an QuerySpecificFileRequest command to response whether the server has a valid + * file for the client or not. If the server has the file, information regarding the file and OTA process will be included in the + * command. + * + * Cluster: Over the Air Bootloading, This cluster contains commands and attributes that act as an interface for ZigBee Over-the-air + * bootloading. Command: QuerySpecificFileResponse * @param status uint8_t * @param manufacturerId uint16_t * @param imageType uint16_t * @param fileVersion uint32_t * @param imageSize uint32_t */ -#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileResponse(status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - imageSize) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ - ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID, \ - "uvvww", \ - status, \ - manufacturerId, \ - imageType, \ - fileVersion, \ - imageSize); - +#define emberAfFillCommandOtaBootloadClusterQuerySpecificFileResponse(status, manufacturerId, imageType, fileVersion, imageSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_OTA_BOOTLOAD_CLUSTER_ID, \ + ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID, "uvvww", status, manufacturerId, imageType, \ + fileVersion, imageSize); /** @} END Over the Air Bootloading Commands */ - /** @name Power Profile Commands */ // @{ -/** @brief The PowerProfileRequest Command is generated by a device supporting the client side of the Power Profile cluster in order to request the Power Profile of a server device. +/** @brief The PowerProfileRequest Command is generated by a device supporting the client side of the Power Profile cluster in order + * to request the Power Profile of a server device. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileRequest + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileRequest * @param powerProfileId uint8_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileRequest(powerProfileId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_REQUEST_COMMAND_ID, \ - "u", \ - powerProfileId); - +#define emberAfFillCommandPowerProfileClusterPowerProfileRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_REQUEST_COMMAND_ID, "u", powerProfileId); /** @brief The PowerProfileStateRequest Command is generated in order to retrieve the identifiers of current Power Profiles. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileStateRequest + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileStateRequest */ -#define emberAfFillCommandPowerProfileClusterPowerProfileStateRequest() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPowerProfileClusterPowerProfileStateRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID, ""); -/** @brief The GetPowerProfilePriceResponse command allows a device (client) to communicate the cost associated to the selected Power Profile to another device (server) requesting it. +/** @brief The GetPowerProfilePriceResponse command allows a device (client) to communicate the cost associated to the selected + * Power Profile to another device (server) requesting it. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetPowerProfilePriceResponse + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetPowerProfilePriceResponse * @param powerProfileId uint8_t * @param currency uint16_t * @param price uint32_t * @param priceTrailingDigit uint8_t */ -#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceResponse(powerProfileId, \ - currency, \ - price, \ - priceTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID, \ - "uvwu", \ - powerProfileId, \ - currency, \ - price, \ - priceTrailingDigit); - - -/** @brief The GetOverallSchedulePriceResponse command allows a device (client) to communicate the overall cost associated to all Power Profiles scheduled to another device (server) requesting it. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetOverallSchedulePriceResponse +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceResponse(powerProfileId, currency, price, priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID, "uvwu", powerProfileId, currency, price, \ + priceTrailingDigit); + +/** @brief The GetOverallSchedulePriceResponse command allows a device (client) to communicate the overall cost associated to all + * Power Profiles scheduled to another device (server) requesting it. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetOverallSchedulePriceResponse * @param currency uint16_t * @param price uint32_t * @param priceTrailingDigit uint8_t */ -#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePriceResponse(currency, \ - price, \ - priceTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID, \ - "vwu", \ - currency, \ - price, \ - priceTrailingDigit); +#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePriceResponse(currency, price, priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID, "vwu", currency, price, priceTrailingDigit); - -/** @brief The EnergyPhasesScheduleNotification Command is generated by a device supporting the client side of the Power Profile cluster in order to schedule the start of the selected Power Profile and its phases. +/** @brief The EnergyPhasesScheduleNotification Command is generated by a device supporting the client side of the Power Profile + * cluster in order to schedule the start of the selected Power Profile and its phases. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleNotification + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleNotification * @param powerProfileId uint8_t * @param numOfScheduledPhases uint8_t * @param scheduledPhases uint8_t* * @param scheduledPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleNotification(powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID, \ - "uub", \ - powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen); - - -/** @brief This command is generated by the client side of Power Profile cluster as a reply to the EnergyPhasesScheduleRequest command. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleResponse +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleNotification(powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID, "uub", powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen); + +/** @brief This command is generated by the client side of Power Profile cluster as a reply to the EnergyPhasesScheduleRequest + * command. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleResponse * @param powerProfileId uint8_t * @param numOfScheduledPhases uint8_t * @param scheduledPhases uint8_t* * @param scheduledPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleResponse(powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID, \ - "uub", \ - powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen); - - -/** @brief The PowerProfileScheduleConstraintsRequest Command is generated by a device supporting the client side of the Power Profile cluster in order to request the constraints -if set- of Power Profile of a client device, in order to set the proper boundaries for the scheduling when calculating the schedules. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileScheduleConstraintsRequest +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleResponse(powerProfileId, numOfScheduledPhases, scheduledPhases, \ + scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID, "uub", powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen); + +/** @brief The PowerProfileScheduleConstraintsRequest Command is generated by a device supporting the client side of the Power + * Profile cluster in order to request the constraints -if set- of Power Profile of a client device, in order to set the proper + * boundaries for the scheduling when calculating the schedules. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileScheduleConstraintsRequest * @param powerProfileId uint8_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsRequest(powerProfileId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID, \ - "u", \ - powerProfileId); - +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID, "u", powerProfileId); -/** @brief The EnergyPhasesScheduleStateRequest Command is generated by a device supporting the client side of the Power Profile cluster to check the states of the scheduling of a power profile, which is supported in the device implementing the server side of Power Profile cluster. +/** @brief The EnergyPhasesScheduleStateRequest Command is generated by a device supporting the client side of the Power Profile + * cluster to check the states of the scheduling of a power profile, which is supported in the device implementing the server side + * of Power Profile cluster. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleStateRequest + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleStateRequest * @param powerProfileId uint8_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateRequest(powerProfileId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID, \ - "u", \ - powerProfileId); +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID, "u", powerProfileId); - -/** @brief The Get Power Profile Price Extended Response command allows a device (client) to communicate the cost associated to all Power Profiles scheduled to another device (server) requesting it according to the specific options contained in the Get Power Profile Price Extended Response. +/** @brief The Get Power Profile Price Extended Response command allows a device (client) to communicate the cost associated to all + * Power Profiles scheduled to another device (server) requesting it according to the specific options contained in the Get Power + * Profile Price Extended Response. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetPowerProfilePriceExtendedResponse + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetPowerProfilePriceExtendedResponse * @param powerProfileId uint8_t * @param currency uint16_t * @param price uint32_t * @param priceTrailingDigit uint8_t */ -#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtendedResponse(powerProfileId, \ - currency, \ - price, \ - priceTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID, \ - "uvwu", \ - powerProfileId, \ - currency, \ - price, \ - priceTrailingDigit); - - -/** @brief The PowerProfileNotification Command is generated by a device supporting the server side of the Power Profile cluster in order to send the information of the specific parameters (such as Peak power and others) belonging to each phase. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileNotification +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtendedResponse(powerProfileId, currency, price, \ + priceTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID, "uvwu", powerProfileId, currency, price, \ + priceTrailingDigit); + +/** @brief The PowerProfileNotification Command is generated by a device supporting the server side of the Power Profile cluster in + * order to send the information of the specific parameters (such as Peak power and others) belonging to each phase. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileNotification * @param totalProfileNum uint8_t * @param powerProfileId uint8_t * @param numOfTransferredPhases uint8_t * @param transferredPhases uint8_t* * @param transferredPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileNotification(totalProfileNum, \ - powerProfileId, \ - numOfTransferredPhases, \ - transferredPhases, \ - transferredPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID, \ - "uuub", \ - totalProfileNum, \ - powerProfileId, \ - numOfTransferredPhases, \ - transferredPhases, \ - transferredPhasesLen); - +#define emberAfFillCommandPowerProfileClusterPowerProfileNotification(totalProfileNum, powerProfileId, numOfTransferredPhases, \ + transferredPhases, transferredPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID, "uuub", totalProfileNum, powerProfileId, \ + numOfTransferredPhases, transferredPhases, transferredPhasesLen); /** @brief This command is generated by the server side of Power Profile cluster as a reply to the PowerProfileRequest command. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileResponse + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileResponse * @param totalProfileNum uint8_t * @param powerProfileId uint8_t * @param numOfTransferredPhases uint8_t * @param transferredPhases uint8_t* * @param transferredPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileResponse(totalProfileNum, \ - powerProfileId, \ - numOfTransferredPhases, \ - transferredPhases, \ - transferredPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID, \ - "uuub", \ - totalProfileNum, \ - powerProfileId, \ - numOfTransferredPhases, \ - transferredPhases, \ - transferredPhasesLen); - - -/** @brief The PowerProfileStateResponse command allows a device (server) to communicate its current Power Profile(s) to another device (client) that previously requested them. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileStateResponse +#define emberAfFillCommandPowerProfileClusterPowerProfileResponse(totalProfileNum, powerProfileId, numOfTransferredPhases, \ + transferredPhases, transferredPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID, "uuub", totalProfileNum, powerProfileId, \ + numOfTransferredPhases, transferredPhases, transferredPhasesLen); + +/** @brief The PowerProfileStateResponse command allows a device (server) to communicate its current Power Profile(s) to another + * device (client) that previously requested them. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileStateResponse * @param powerProfileCount uint8_t * @param powerProfileRecords uint8_t* * @param powerProfileRecordsLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileStateResponse(powerProfileCount, \ - powerProfileRecords, \ - powerProfileRecordsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID, \ - "ub", \ - powerProfileCount, \ - powerProfileRecords, \ - powerProfileRecordsLen); +#define emberAfFillCommandPowerProfileClusterPowerProfileStateResponse(powerProfileCount, powerProfileRecords, \ + powerProfileRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID, "ub", powerProfileCount, powerProfileRecords, \ + powerProfileRecordsLen); - -/** @brief The GetPowerProfilePrice Command is generated by the server (e.g. White goods) in order to retrieve the cost associated to a specific Power profile. +/** @brief The GetPowerProfilePrice Command is generated by the server (e.g. White goods) in order to retrieve the cost associated + * to a specific Power profile. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetPowerProfilePrice + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetPowerProfilePrice * @param powerProfileId uint8_t */ -#define emberAfFillCommandPowerProfileClusterGetPowerProfilePrice(powerProfileId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID, \ - "u", \ - powerProfileId); - +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePrice(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID, "u", powerProfileId); -/** @brief The PowerProfileStateNotification Command is generated by the server (e.g. White goods) in order to update the state of the power profile and the current energy phase. +/** @brief The PowerProfileStateNotification Command is generated by the server (e.g. White goods) in order to update the state of + * the power profile and the current energy phase. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfilesStateNotification + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfilesStateNotification * @param powerProfileCount uint8_t * @param powerProfileRecords uint8_t* * @param powerProfileRecordsLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfilesStateNotification(powerProfileCount, \ - powerProfileRecords, \ - powerProfileRecordsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID, \ - "ub", \ - powerProfileCount, \ - powerProfileRecords, \ - powerProfileRecordsLen); +#define emberAfFillCommandPowerProfileClusterPowerProfilesStateNotification(powerProfileCount, powerProfileRecords, \ + powerProfileRecordsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID, "ub", powerProfileCount, powerProfileRecords, \ + powerProfileRecordsLen); - -/** @brief The GetOverallSchedulePrice Command is generated by the server (e.g. White goods) in order to retrieve the overall cost associated to all the Power Profiles scheduled by the scheduler (the device supporting the Power Profile cluster client side) for the next 24 hours. +/** @brief The GetOverallSchedulePrice Command is generated by the server (e.g. White goods) in order to retrieve the overall cost + * associated to all the Power Profiles scheduled by the scheduler (the device supporting the Power Profile cluster client side) for + * the next 24 hours. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetOverallSchedulePrice + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetOverallSchedulePrice */ -#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePrice() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPowerProfileClusterGetOverallSchedulePrice() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID, ""); -/** @brief The EnergyPhasesScheduleRequest Command is generated by the server (e.g. White goods) in order to retrieve from the scheduler (e.g. Home Gateway) the schedule (if available) associated to the specific Power Profile carried in the payload. +/** @brief The EnergyPhasesScheduleRequest Command is generated by the server (e.g. White goods) in order to retrieve from the + * scheduler (e.g. Home Gateway) the schedule (if available) associated to the specific Power Profile carried in the payload. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleRequest + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleRequest * @param powerProfileId uint8_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleRequest(powerProfileId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID, \ - "u", \ - powerProfileId); +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleRequest(powerProfileId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID, "u", powerProfileId); - -/** @brief The EnergyPhasesScheduleStateResponse Command is generated by the server (e.g. White goods) in order to reply to a EnergyPhasesScheduleStateRequest command about the scheduling states that are set in the server side. +/** @brief The EnergyPhasesScheduleStateResponse Command is generated by the server (e.g. White goods) in order to reply to a + * EnergyPhasesScheduleStateRequest command about the scheduling states that are set in the server side. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleStateResponse + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleStateResponse * @param powerProfileId uint8_t * @param numOfScheduledPhases uint8_t * @param scheduledPhases uint8_t* * @param scheduledPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateResponse(powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID, \ - "uub", \ - powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen); - - -/** @brief The EnergyPhasesScheduleStateNotification Command is generated by the server (e.g. White goods) in order to notify (un-solicited command) a client side about the scheduling states that are set in the server side. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: EnergyPhasesScheduleStateNotification +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateResponse(powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID, "uub", powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen); + +/** @brief The EnergyPhasesScheduleStateNotification Command is generated by the server (e.g. White goods) in order to notify + * (un-solicited command) a client side about the scheduling states that are set in the server side. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: EnergyPhasesScheduleStateNotification * @param powerProfileId uint8_t * @param numOfScheduledPhases uint8_t * @param scheduledPhases uint8_t* * @param scheduledPhasesLen uint16_t */ -#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateNotification(powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID, \ - "uub", \ - powerProfileId, \ - numOfScheduledPhases, \ - scheduledPhases, \ - scheduledPhasesLen); - - -/** @brief The PowerProfileScheduleConstraintsNotification Command is generated by a device supporting the server side of the Power Profile cluster to notify the client side of this cluster about the imposed constraints and let the scheduler (i.e. the entity supporting the Power Profile cluster client side) to set the proper boundaries for the scheduling. - * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileScheduleConstraintsNotification +#define emberAfFillCommandPowerProfileClusterEnergyPhasesScheduleStateNotification(powerProfileId, numOfScheduledPhases, \ + scheduledPhases, scheduledPhasesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID, "uub", powerProfileId, \ + numOfScheduledPhases, scheduledPhases, scheduledPhasesLen); + +/** @brief The PowerProfileScheduleConstraintsNotification Command is generated by a device supporting the server side of the Power + * Profile cluster to notify the client side of this cluster about the imposed constraints and let the scheduler (i.e. the entity + * supporting the Power Profile cluster client side) to set the proper boundaries for the scheduling. + * + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileScheduleConstraintsNotification * @param powerProfileId uint8_t * @param startAfter uint16_t * @param stopBefore uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsNotification(powerProfileId, \ - startAfter, \ - stopBefore) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID, \ - "uvv", \ - powerProfileId, \ - startAfter, \ - stopBefore); - +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsNotification(powerProfileId, startAfter, stopBefore) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID, "uvv", powerProfileId, startAfter, \ + stopBefore); -/** @brief The PowerProfileScheduleConstraintsResponse Command is generated by a device supporting the server side of the Power Profile cluster to reply to a client side of this cluster which sent a PowerProfileScheduleConstraintsRequest. +/** @brief The PowerProfileScheduleConstraintsResponse Command is generated by a device supporting the server side of the Power + * Profile cluster to reply to a client side of this cluster which sent a PowerProfileScheduleConstraintsRequest. * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: PowerProfileScheduleConstraintsResponse + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: PowerProfileScheduleConstraintsResponse * @param powerProfileId uint8_t * @param startAfter uint16_t * @param stopBefore uint16_t */ -#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsResponse(powerProfileId, \ - startAfter, \ - stopBefore) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID, \ - "uvv", \ - powerProfileId, \ - startAfter, \ - stopBefore); +#define emberAfFillCommandPowerProfileClusterPowerProfileScheduleConstraintsResponse(powerProfileId, startAfter, stopBefore) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID, "uvv", powerProfileId, startAfter, \ + stopBefore); - -/** @brief The Get Power Profile Price Extended command is generated by the server (e.g., White Goods) in order to retrieve the cost associated to a specific Power profile considering specific conditions described in the option field (e.g., a specific time). +/** @brief The Get Power Profile Price Extended command is generated by the server (e.g., White Goods) in order to retrieve the cost + * associated to a specific Power profile considering specific conditions described in the option field (e.g., a specific time). * - * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request command) or can be notified directly from the device (server side). - * Command: GetPowerProfilePriceExtended + * Cluster: Power Profile, This cluster provides an interface for transferring power profile information from a device (e.g. + * Whitegood) to a controller (e.g. the Home Gateway). The Power Profile transferred can be solicited by client side (request + * command) or can be notified directly from the device (server side). Command: GetPowerProfilePriceExtended * @param options uint8_t * @param powerProfileId uint8_t * @param powerProfileStartTime uint16_t */ -#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtended(options, \ - powerProfileId, \ - powerProfileStartTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POWER_PROFILE_CLUSTER_ID, \ - ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID, \ - "uuv", \ - options, \ - powerProfileId, \ - powerProfileStartTime); - +#define emberAfFillCommandPowerProfileClusterGetPowerProfilePriceExtended(options, powerProfileId, powerProfileStartTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POWER_PROFILE_CLUSTER_ID, \ + ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID, "uuv", options, powerProfileId, \ + powerProfileStartTime); /** @} END Power Profile Commands */ - /** @name Appliance Control Commands */ // @{ /** @brief This basic message is used to remotely control and to program household appliances. @@ -3568,29 +2286,21 @@ * Command: ExecutionOfACommand * @param commandId uint8_t */ -#define emberAfFillCommandApplianceControlClusterExecutionOfACommand(commandId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID, \ - "u", \ - commandId); - +#define emberAfFillCommandApplianceControlClusterExecutionOfACommand(commandId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID, "u", commandId); /** @brief This basic message is used to retrieve Household Appliances status. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: SignalState */ -#define emberAfFillCommandApplianceControlClusterSignalState() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_SIGNAL_STATE_COMMAND_ID, \ - ""); +#define emberAfFillCommandApplianceControlClusterSignalState() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_SIGNAL_STATE_COMMAND_ID, ""); - -/** @brief This basic message is used to set appliance functions, i.e. information regarding the execution of an appliance cycle. Condition parameters such as start time or finish time information could be provided through this command. +/** @brief This basic message is used to set appliance functions, i.e. information regarding the execution of an appliance cycle. + * Condition parameters such as start time or finish time information could be provided through this command. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: WriteFunctions @@ -3599,63 +2309,43 @@ * @param functionData uint8_t* * @param functionDataLen uint16_t */ -#define emberAfFillCommandApplianceControlClusterWriteFunctions(functionId, \ - functionDataType, \ - functionData, \ - functionDataLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_WRITE_FUNCTIONS_COMMAND_ID, \ - "vub", \ - functionId, \ - functionDataType, \ - functionData, \ - functionDataLen); - +#define emberAfFillCommandApplianceControlClusterWriteFunctions(functionId, functionDataType, functionData, functionDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_WRITE_FUNCTIONS_COMMAND_ID, "vub", functionId, \ + functionDataType, functionData, functionDataLen); -/** @brief This command shall be used to resume the normal behavior of a household appliance being in pause mode after receiving a Overload Pause command. +/** @brief This command shall be used to resume the normal behavior of a household appliance being in pause mode after receiving a + * Overload Pause command. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: OverloadPauseResume */ -#define emberAfFillCommandApplianceControlClusterOverloadPauseResume() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandApplianceControlClusterOverloadPauseResume() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID, ""); /** @brief This command shall be used to pause the household appliance as a consequence of an imminent overload event. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: OverloadPause */ -#define emberAfFillCommandApplianceControlClusterOverloadPause() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_OVERLOAD_PAUSE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandApplianceControlClusterOverloadPause() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_OVERLOAD_PAUSE_COMMAND_ID, ""); -/** @brief This basic message is used to send warnings the household appliance as a consequence of a possible overload event, or the notification of the end of the warning state. +/** @brief This basic message is used to send warnings the household appliance as a consequence of a possible overload event, or the + * notification of the end of the warning state. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: OverloadWarning * @param warningEvent uint8_t */ -#define emberAfFillCommandApplianceControlClusterOverloadWarning(warningEvent) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_OVERLOAD_WARNING_COMMAND_ID, \ - "u", \ - warningEvent); +#define emberAfFillCommandApplianceControlClusterOverloadWarning(warningEvent) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_OVERLOAD_WARNING_COMMAND_ID, "u", warningEvent); - -/** @brief This command shall be used to return household appliance status, according to Appliance Status Values and Remote Enable Flags Values. +/** @brief This command shall be used to return household appliance status, according to Appliance Status Values and Remote Enable + * Flags Values. * * Cluster: Appliance Control, This cluster provides an interface to remotely control and to program household appliances. * Command: SignalStateResponse @@ -3663,18 +2353,11 @@ * @param remoteEnableFlagsAndDeviceStatus2 uint8_t * @param applianceStatus2 uint32_t */ -#define emberAfFillCommandApplianceControlClusterSignalStateResponse(applianceStatus, \ - remoteEnableFlagsAndDeviceStatus2, \ - applianceStatus2) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID, \ - "uux", \ - applianceStatus, \ - remoteEnableFlagsAndDeviceStatus2, \ - applianceStatus2); - +#define emberAfFillCommandApplianceControlClusterSignalStateResponse(applianceStatus, remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID, "uux", applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, applianceStatus2); /** @brief This command shall be used to return household appliance status, automatically when appliance status changes. * @@ -3684,101 +2367,73 @@ * @param remoteEnableFlagsAndDeviceStatus2 uint8_t * @param applianceStatus2 uint32_t */ -#define emberAfFillCommandApplianceControlClusterSignalStateNotification(applianceStatus, \ - remoteEnableFlagsAndDeviceStatus2, \ - applianceStatus2) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_CONTROL_CLUSTER_ID, \ - ZCL_SIGNAL_STATE_NOTIFICATION_COMMAND_ID, \ - "uux", \ - applianceStatus, \ - remoteEnableFlagsAndDeviceStatus2, \ - applianceStatus2); - +#define emberAfFillCommandApplianceControlClusterSignalStateNotification(applianceStatus, remoteEnableFlagsAndDeviceStatus2, \ + applianceStatus2) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_CONTROL_CLUSTER_ID, ZCL_SIGNAL_STATE_NOTIFICATION_COMMAND_ID, "uux", applianceStatus, \ + remoteEnableFlagsAndDeviceStatus2, applianceStatus2); /** @} END Appliance Control Commands */ - /** @name Poll Control Commands */ // @{ -/** @brief The Poll Control Cluster server sends out a Check-in command to the devices to which it is paired based on the server's Check-in Interval attribute. +/** @brief The Poll Control Cluster server sends out a Check-in command to the devices to which it is paired based on the server's + * Check-in Interval attribute. * - * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. - * Command: CheckIn + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the + * purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's + * parent. Command: CheckIn */ -#define emberAfFillCommandPollControlClusterCheckIn() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_POLL_CONTROL_CLUSTER_ID, \ - ZCL_CHECK_IN_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPollControlClusterCheckIn() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_CHECK_IN_COMMAND_ID, ""); /** @brief The Check-in Response is sent in response to the receipt of a Check-in command. * - * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. - * Command: CheckInResponse + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the + * purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's + * parent. Command: CheckInResponse * @param startFastPolling uint8_t * @param fastPollTimeout uint16_t */ -#define emberAfFillCommandPollControlClusterCheckInResponse(startFastPolling, \ - fastPollTimeout) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POLL_CONTROL_CLUSTER_ID, \ - ZCL_CHECK_IN_RESPONSE_COMMAND_ID, \ - "uv", \ - startFastPolling, \ - fastPollTimeout); - +#define emberAfFillCommandPollControlClusterCheckInResponse(startFastPolling, fastPollTimeout) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_CHECK_IN_RESPONSE_COMMAND_ID, "uv", startFastPolling, fastPollTimeout); /** @brief The Fast Poll Stop command is used to stop the fast poll mode initiated by the Check-in response. * - * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. - * Command: FastPollStop + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the + * purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's + * parent. Command: FastPollStop */ -#define emberAfFillCommandPollControlClusterFastPollStop() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POLL_CONTROL_CLUSTER_ID, \ - ZCL_FAST_POLL_STOP_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPollControlClusterFastPollStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_FAST_POLL_STOP_COMMAND_ID, ""); /** @brief The Set Long Poll Interval command is used to set the read only Long Poll Interval Attribute. * - * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. - * Command: SetLongPollInterval + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the + * purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's + * parent. Command: SetLongPollInterval * @param newLongPollInterval uint32_t */ -#define emberAfFillCommandPollControlClusterSetLongPollInterval(newLongPollInterval) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POLL_CONTROL_CLUSTER_ID, \ - ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID, \ - "w", \ - newLongPollInterval); - +#define emberAfFillCommandPollControlClusterSetLongPollInterval(newLongPollInterval) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID, "w", newLongPollInterval); /** @brief The Set Short Poll Interval command is used to set the read only Short Poll Interval Attribute. * - * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's parent. - * Command: SetShortPollInterval + * Cluster: Poll Control, This cluster provides a mechanism for the management of an end device's MAC Data Poll rate. For the + * purposes of this cluster, the term "poll" always refers to the sending of a MAC Data Poll from the end device to the end device's + * parent. Command: SetShortPollInterval * @param newShortPollInterval uint16_t */ -#define emberAfFillCommandPollControlClusterSetShortPollInterval(newShortPollInterval) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_POLL_CONTROL_CLUSTER_ID, \ - ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID, \ - "v", \ - newShortPollInterval); - +#define emberAfFillCommandPollControlClusterSetShortPollInterval(newShortPollInterval) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_POLL_CONTROL_CLUSTER_ID, \ + ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID, "v", newShortPollInterval); /** @} END Poll Control Commands */ - /** @name Green Power Commands */ // @{ /** @brief From GPP to GPS to tunnel GP frame. @@ -3795,30 +2450,11 @@ * @param gppShortAddress uint16_t * @param gppDistance uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpNotification(options, \ - gpdSrcId, \ - gpdIeee, \ - gpdEndpoint, \ - gpdSecurityFrameCounter, \ - gpdCommandId, \ - gpdCommandPayload, \ - gppShortAddress, \ - gppDistance) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_NOTIFICATION_COMMAND_ID, \ - "vw8uwusvu", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - gpdEndpoint, \ - gpdSecurityFrameCounter, \ - gpdCommandId, \ - gpdCommandPayload, \ - gppShortAddress, \ - gppDistance); - +#define emberAfFillCommandGreenPowerClusterGpNotification(options, gpdSrcId, gpdIeee, gpdEndpoint, gpdSecurityFrameCounter, \ + gpdCommandId, gpdCommandPayload, gppShortAddress, gppDistance) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_NOTIFICATION_COMMAND_ID, "vw8uwusvu", options, gpdSrcId, gpdIeee, gpdEndpoint, \ + gpdSecurityFrameCounter, gpdCommandId, gpdCommandPayload, gppShortAddress, gppDistance); /** @brief From GPP to GPSs in entire network to get pairing indication related to GPD for Proxy Table update. * @@ -3829,20 +2465,9 @@ * @param gpdIeee uint8_t* * @param endpoint uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpPairingSearch(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PAIRING_SEARCH_COMMAND_ID, \ - "vw8u", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint); - +#define emberAfFillCommandGreenPowerClusterGpPairingSearch(options, gpdSrcId, gpdIeee, endpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_SEARCH_COMMAND_ID, "vw8u", options, gpdSrcId, gpdIeee, endpoint); /** @brief From GPP to neighbor GPPs to indicate GP Notification sent in unicast mode. * @@ -3856,26 +2481,11 @@ * @param gppShortAddress uint16_t * @param gppDistance int8_t */ -#define emberAfFillCommandGreenPowerClusterGpTunnelingStop(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter, \ - gppShortAddress, \ - gppDistance) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_TUNNELING_STOP_COMMAND_ID, \ - "uw8uwvu", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter, \ - gppShortAddress, \ - gppDistance); - +#define emberAfFillCommandGreenPowerClusterGpTunnelingStop(options, gpdSrcId, gpdIeee, endpoint, gpdSecurityFrameCounter, \ + gppShortAddress, gppDistance) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TUNNELING_STOP_COMMAND_ID, "uw8uwvu", options, gpdSrcId, gpdIeee, endpoint, \ + gpdSecurityFrameCounter, gppShortAddress, gppDistance); /** @brief From GPP to GPS to tunnel GPD commissioning data. * @@ -3892,32 +2502,11 @@ * @param gppLink uint8_t * @param mic uint32_t */ -#define emberAfFillCommandGreenPowerClusterGpCommissioningNotification(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter, \ - gpdCommandId, \ - gpdCommandPayload, \ - gppShortAddress, \ - gppLink, \ - mic) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID, \ - "vw8uwusvuw", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter, \ - gpdCommandId, \ - gpdCommandPayload, \ - gppShortAddress, \ - gppLink, \ - mic); - +#define emberAfFillCommandGreenPowerClusterGpCommissioningNotification( \ + options, gpdSrcId, gpdIeee, endpoint, gpdSecurityFrameCounter, gpdCommandId, gpdCommandPayload, gppShortAddress, gppLink, mic) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID, "vw8uwusvuw", options, gpdSrcId, gpdIeee, endpoint, \ + gpdSecurityFrameCounter, gpdCommandId, gpdCommandPayload, gppShortAddress, gppLink, mic); /** @brief To enable commissioning mode of the sink, over the air * @@ -3928,20 +2517,10 @@ * @param gpmAddrForPairing uint16_t * @param sinkEndpoint uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpSinkCommissioningMode(options, \ - gpmAddrForSecurity, \ - gpmAddrForPairing, \ - sinkEndpoint) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID, \ - "uvvu", \ - options, \ - gpmAddrForSecurity, \ - gpmAddrForPairing, \ - sinkEndpoint); - +#define emberAfFillCommandGreenPowerClusterGpSinkCommissioningMode(options, gpmAddrForSecurity, gpmAddrForPairing, sinkEndpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID, "uvvu", options, gpmAddrForSecurity, gpmAddrForPairing, \ + sinkEndpoint); /** @brief To configure GPD Command Translation Table. * @@ -3954,24 +2533,11 @@ * @param translations uint8_t* * @param translationsLen uint16_t */ -#define emberAfFillCommandGreenPowerClusterGpTranslationTableUpdate(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - translations, \ - translationsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID, \ - "vw8ub", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - translations, \ - translationsLen); - +#define emberAfFillCommandGreenPowerClusterGpTranslationTableUpdate(options, gpdSrcId, gpdIeee, endpoint, translations, \ + translationsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID, "vw8ub", options, gpdSrcId, gpdIeee, endpoint, \ + translations, translationsLen); /** @brief To provide GPD Command Translation Table content. * @@ -3979,14 +2545,9 @@ * Command: GpTranslationTableRequest * @param startIndex uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpTranslationTableRequest(startIndex) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID, \ - "u", \ - startIndex); - +#define emberAfFillCommandGreenPowerClusterGpTranslationTableRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID, "u", startIndex); /** @brief To configure Sink Table. * @@ -4028,82 +2589,22 @@ * @param reportDescriptor uint8_t* * @param reportDescriptorLen uint16_t */ -#define emberAfFillCommandGreenPowerClusterGpPairingConfiguration(actions, \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - deviceId, \ - groupListCount, \ - groupList, \ - groupListLen, \ - gpdAssignedAlias, \ - groupcastRadius, \ - securityOptions, \ - gpdSecurityFrameCounter, \ - gpdSecurityKey, \ - numberOfPairedEndpoints, \ - pairedEndpoints, \ - pairedEndpointsLen, \ - applicationInformation, \ - manufacturerId, \ - modeId, \ - numberOfGpdCommands, \ - gpdCommandIdList, \ - gpdCommandIdListLen, \ - clusterIdListCount, \ - clusterListServer, \ - clusterListServerLen, \ - clusterListClient, \ - clusterListClientLen, \ - switchInformationLength, \ - switchConfiguration, \ - currentContactStatus, \ - totalNumberOfReports, \ - numberOfReports, \ - reportDescriptor, \ - reportDescriptorLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID, \ - "uvw8uuubvuuwGubuvvububbuuuuub", \ - actions, \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - deviceId, \ - groupListCount, \ - groupList, \ - groupListLen, \ - gpdAssignedAlias, \ - groupcastRadius, \ - securityOptions, \ - gpdSecurityFrameCounter, \ - gpdSecurityKey, \ - numberOfPairedEndpoints, \ - pairedEndpoints, \ - pairedEndpointsLen, \ - applicationInformation, \ - manufacturerId, \ - modeId, \ - numberOfGpdCommands, \ - gpdCommandIdList, \ - gpdCommandIdListLen, \ - clusterIdListCount, \ - clusterListServer, \ - clusterListServerLen, \ - clusterListClient, \ - clusterListClientLen, \ - switchInformationLength, \ - switchConfiguration, \ - currentContactStatus, \ - totalNumberOfReports, \ - numberOfReports, \ - reportDescriptor, \ - reportDescriptorLen); - +#define emberAfFillCommandGreenPowerClusterGpPairingConfiguration( \ + actions, options, gpdSrcId, gpdIeee, endpoint, deviceId, groupListCount, groupList, groupListLen, gpdAssignedAlias, \ + groupcastRadius, securityOptions, gpdSecurityFrameCounter, gpdSecurityKey, numberOfPairedEndpoints, pairedEndpoints, \ + pairedEndpointsLen, applicationInformation, manufacturerId, modeId, numberOfGpdCommands, gpdCommandIdList, \ + gpdCommandIdListLen, clusterIdListCount, clusterListServer, clusterListServerLen, clusterListClient, clusterListClientLen, \ + switchInformationLength, switchConfiguration, currentContactStatus, totalNumberOfReports, numberOfReports, reportDescriptor, \ + reportDescriptorLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID, "uvw8uuubvuuwGubuvvububbuuuuub", actions, options, \ + gpdSrcId, gpdIeee, endpoint, deviceId, groupListCount, groupList, groupListLen, gpdAssignedAlias, \ + groupcastRadius, securityOptions, gpdSecurityFrameCounter, gpdSecurityKey, numberOfPairedEndpoints, \ + pairedEndpoints, pairedEndpointsLen, applicationInformation, manufacturerId, modeId, \ + numberOfGpdCommands, gpdCommandIdList, gpdCommandIdListLen, clusterIdListCount, clusterListServer, \ + clusterListServerLen, clusterListClient, clusterListClientLen, switchInformationLength, \ + switchConfiguration, currentContactStatus, totalNumberOfReports, numberOfReports, reportDescriptor, \ + reportDescriptorLen); /** @brief To read out selected Sink Table Entries, by index or by GPD ID. * @@ -4115,22 +2616,9 @@ * @param endpoint uint8_t * @param index uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpSinkTableRequest(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - index) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID, \ - "uw8uu", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - index); - +#define emberAfFillCommandGreenPowerClusterGpSinkTableRequest(options, gpdSrcId, gpdIeee, endpoint, index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID, "uw8uu", options, gpdSrcId, gpdIeee, endpoint, index); /** @brief To reply with read-out Proxy Table entries, by index or by GPD ID. * @@ -4143,24 +2631,11 @@ * @param proxyTableEntries uint8_t* * @param proxyTableEntriesLen uint16_t */ -#define emberAfFillCommandGreenPowerClusterGpProxyTableResponse(status, \ - totalNumberOfNonEmptyProxyTableEntries, \ - startIndex, \ - entriesCount, \ - proxyTableEntries, \ - proxyTableEntriesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID, \ - "uuuub", \ - status, \ - totalNumberOfNonEmptyProxyTableEntries, \ - startIndex, \ - entriesCount, \ - proxyTableEntries, \ - proxyTableEntriesLen); - +#define emberAfFillCommandGreenPowerClusterGpProxyTableResponse(status, totalNumberOfNonEmptyProxyTableEntries, startIndex, \ + entriesCount, proxyTableEntries, proxyTableEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID, "uuuub", status, totalNumberOfNonEmptyProxyTableEntries, \ + startIndex, entriesCount, proxyTableEntries, proxyTableEntriesLen); /** @brief From GPS to GPP to acknowledge GP Notification received in unicast mode. * @@ -4172,22 +2647,10 @@ * @param endpoint uint8_t * @param gpdSecurityFrameCounter uint32_t */ -#define emberAfFillCommandGreenPowerClusterGpNotificationResponse(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID, \ - "uw8uw", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdSecurityFrameCounter); - +#define emberAfFillCommandGreenPowerClusterGpNotificationResponse(options, gpdSrcId, gpdIeee, endpoint, gpdSecurityFrameCounter) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID, "uw8uw", options, gpdSrcId, gpdIeee, endpoint, \ + gpdSecurityFrameCounter); /** @brief From GPS to the entire network to (de)register for tunneling service, or for removing GPD from the network. * @@ -4206,36 +2669,13 @@ * @param assignedAlias uint16_t * @param groupcastRadius uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpPairing(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - sinkIeeeAddress, \ - sinkNwkAddress, \ - sinkGroupId, \ - deviceId, \ - gpdSecurityFrameCounter, \ - gpdKey, \ - assignedAlias, \ - groupcastRadius) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PAIRING_COMMAND_ID, \ - "xw8u8vvuwGvu", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - sinkIeeeAddress, \ - sinkNwkAddress, \ - sinkGroupId, \ - deviceId, \ - gpdSecurityFrameCounter, \ - gpdKey, \ - assignedAlias, \ - groupcastRadius); - +#define emberAfFillCommandGreenPowerClusterGpPairing(options, gpdSrcId, gpdIeee, endpoint, sinkIeeeAddress, sinkNwkAddress, \ + sinkGroupId, deviceId, gpdSecurityFrameCounter, gpdKey, assignedAlias, \ + groupcastRadius) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PAIRING_COMMAND_ID, "xw8u8vvuwGvu", options, gpdSrcId, gpdIeee, endpoint, sinkIeeeAddress, \ + sinkNwkAddress, sinkGroupId, deviceId, gpdSecurityFrameCounter, gpdKey, assignedAlias, \ + groupcastRadius); /** @brief From GPS to GPPs in the whole network to indicate commissioning mode. * @@ -4245,18 +2685,9 @@ * @param commissioningWindow uint16_t * @param channel uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpProxyCommissioningMode(options, \ - commissioningWindow, \ - channel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID, \ - "uvu", \ - options, \ - commissioningWindow, \ - channel); - +#define emberAfFillCommandGreenPowerClusterGpProxyCommissioningMode(options, commissioningWindow, channel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID, "uvu", options, commissioningWindow, channel); /** @brief From GPS to selected GPP, to provide data to be transmitted to Rx-capable GPD. * @@ -4271,28 +2702,11 @@ * @param gpdCommandId uint8_t * @param gpdCommandPayload uint8_t* */ -#define emberAfFillCommandGreenPowerClusterGpResponse(options, \ - tempMasterShortAddress, \ - tempMasterTxChannel, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdCommandId, \ - gpdCommandPayload) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_RESPONSE_COMMAND_ID, \ - "uvuw8uus", \ - options, \ - tempMasterShortAddress, \ - tempMasterTxChannel, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - gpdCommandId, \ - gpdCommandPayload); - +#define emberAfFillCommandGreenPowerClusterGpResponse(options, tempMasterShortAddress, tempMasterTxChannel, gpdSrcId, gpdIeee, \ + endpoint, gpdCommandId, gpdCommandPayload) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_RESPONSE_COMMAND_ID, "uvuw8uus", options, tempMasterShortAddress, tempMasterTxChannel, \ + gpdSrcId, gpdIeee, endpoint, gpdCommandId, gpdCommandPayload); /** @brief To provide GPD Command Translation Table content. * @@ -4306,26 +2720,11 @@ * @param translationTableList uint8_t* * @param translationTableListLen uint16_t */ -#define emberAfFillCommandGreenPowerClusterGpTranslationTableResponse(status, \ - options, \ - totalNumberOfEntries, \ - startIndex, \ - entriesCount, \ - translationTableList, \ - translationTableListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_TRANSLATION_TABLE_RESPONSE_COMMAND_ID, \ - "uuuuub", \ - status, \ - options, \ - totalNumberOfEntries, \ - startIndex, \ - entriesCount, \ - translationTableList, \ - translationTableListLen); - +#define emberAfFillCommandGreenPowerClusterGpTranslationTableResponse(status, options, totalNumberOfEntries, startIndex, \ + entriesCount, translationTableList, translationTableListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_TRANSLATION_TABLE_RESPONSE_COMMAND_ID, "uuuuub", status, options, totalNumberOfEntries, \ + startIndex, entriesCount, translationTableList, translationTableListLen); /** @brief To selected Proxy Table entries, by index or by GPD ID. * @@ -4338,24 +2737,11 @@ * @param sinkTableEntries uint8_t* * @param sinkTableEntriesLen uint16_t */ -#define emberAfFillCommandGreenPowerClusterGpSinkTableResponse(status, \ - totalNumberofNonEmptySinkTableEntries, \ - startIndex, \ - sinkTableEntriesCount, \ - sinkTableEntries, \ - sinkTableEntriesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID, \ - "uuuub", \ - status, \ - totalNumberofNonEmptySinkTableEntries, \ - startIndex, \ - sinkTableEntriesCount, \ - sinkTableEntries, \ - sinkTableEntriesLen); - +#define emberAfFillCommandGreenPowerClusterGpSinkTableResponse(status, totalNumberofNonEmptySinkTableEntries, startIndex, \ + sinkTableEntriesCount, sinkTableEntries, sinkTableEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID, "uuuub", status, totalNumberofNonEmptySinkTableEntries, \ + startIndex, sinkTableEntriesCount, sinkTableEntries, sinkTableEntriesLen); /** @brief To request selected Proxy Table entries, by index or by GPD ID. * @@ -4367,36 +2753,20 @@ * @param endpoint uint8_t * @param index uint8_t */ -#define emberAfFillCommandGreenPowerClusterGpProxyTableRequest(options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - index) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GREEN_POWER_CLUSTER_ID, \ - ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID, \ - "uw8uu", \ - options, \ - gpdSrcId, \ - gpdIeee, \ - endpoint, \ - index); - +#define emberAfFillCommandGreenPowerClusterGpProxyTableRequest(options, gpdSrcId, gpdIeee, endpoint, index) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GREEN_POWER_CLUSTER_ID, \ + ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID, "uw8uu", options, gpdSrcId, gpdIeee, endpoint, index); /** @} END Green Power Commands */ - /** @name Keep-Alive Commands */ // @{ /** @} END Keep-Alive Commands */ - /** @name Shade Configuration Commands */ // @{ /** @} END Shade Configuration Commands */ - /** @name Door Lock Commands */ // @{ /** @brief Locks the door @@ -4405,14 +2775,9 @@ * Command: LockDoor * @param PIN uint8_t* */ -#define emberAfFillCommandDoorLockClusterLockDoor(PIN) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_LOCK_DOOR_COMMAND_ID, \ - "s", \ - PIN); - +#define emberAfFillCommandDoorLockClusterLockDoor(PIN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_LOCK_DOOR_COMMAND_ID, "s", PIN); /** @brief Unlocks the door * @@ -4420,14 +2785,9 @@ * Command: UnlockDoor * @param PIN uint8_t* */ -#define emberAfFillCommandDoorLockClusterUnlockDoor(PIN) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_UNLOCK_DOOR_COMMAND_ID, \ - "s", \ - PIN); - +#define emberAfFillCommandDoorLockClusterUnlockDoor(PIN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_DOOR_COMMAND_ID, "s", PIN); /** @brief Toggles the door lock from its current state to the opposite state locked or unlocked. * @@ -4435,14 +2795,9 @@ * Command: Toggle * @param pin uint8_t* */ -#define emberAfFillCommandDoorLockClusterToggle(pin) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_TOGGLE_COMMAND_ID, \ - "s", \ - pin); - +#define emberAfFillCommandDoorLockClusterToggle(pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_TOGGLE_COMMAND_ID, "s", pin); /** @brief Unlock the door with a timeout. When the timeout expires, the door will automatically re-lock. * @@ -4451,16 +2806,9 @@ * @param timeoutInSeconds uint16_t * @param pin uint8_t* */ -#define emberAfFillCommandDoorLockClusterUnlockWithTimeout(timeoutInSeconds, \ - pin) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID, \ - "vs", \ - timeoutInSeconds, \ - pin); - +#define emberAfFillCommandDoorLockClusterUnlockWithTimeout(timeoutInSeconds, pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID, "vs", timeoutInSeconds, pin); /** @brief Retrieve a log record at a specified index. * @@ -4468,14 +2816,9 @@ * Command: GetLogRecord * @param logIndex uint16_t */ -#define emberAfFillCommandDoorLockClusterGetLogRecord(logIndex) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_LOG_RECORD_COMMAND_ID, \ - "v", \ - logIndex); - +#define emberAfFillCommandDoorLockClusterGetLogRecord(logIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_LOG_RECORD_COMMAND_ID, "v", logIndex); /** @brief Set the PIN for a specified user id. * @@ -4486,20 +2829,9 @@ * @param userType uint8_t * @param pin uint8_t* */ -#define emberAfFillCommandDoorLockClusterSetPin(userId, \ - userStatus, \ - userType, \ - pin) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_PIN_COMMAND_ID, \ - "vuus", \ - userId, \ - userStatus, \ - userType, \ - pin); - +#define emberAfFillCommandDoorLockClusterSetPin(userId, userStatus, userType, pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_PIN_COMMAND_ID, "vuus", userId, userStatus, userType, pin); /** @brief Retrieve PIN information for a user with a specific user ID. * @@ -4507,14 +2839,9 @@ * Command: GetPin * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetPin(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_PIN_COMMAND_ID, \ - "v", \ - userId); - +#define emberAfFillCommandDoorLockClusterGetPin(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_PIN_COMMAND_ID, "v", userId); /** @brief Clear the PIN for a user with a specific user ID * @@ -4522,27 +2849,18 @@ * Command: ClearPin * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterClearPin(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_PIN_COMMAND_ID, \ - "v", \ - userId); - +#define emberAfFillCommandDoorLockClusterClearPin(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_PIN_COMMAND_ID, "v", userId); /** @brief Clear all PIN codes on the lock for all users. * * Cluster: Door Lock, Provides an interface into a generic way to secure a door. * Command: ClearAllPins */ -#define emberAfFillCommandDoorLockClusterClearAllPins() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_ALL_PINS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDoorLockClusterClearAllPins() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_PINS_COMMAND_ID, ""); /** @brief Set the status value for a specified user ID. * @@ -4551,16 +2869,9 @@ * @param userId uint16_t * @param userStatus uint8_t */ -#define emberAfFillCommandDoorLockClusterSetUserStatus(userId, \ - userStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_USER_STATUS_COMMAND_ID, \ - "vu", \ - userId, \ - userStatus); - +#define emberAfFillCommandDoorLockClusterSetUserStatus(userId, userStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_STATUS_COMMAND_ID, "vu", userId, userStatus); /** @brief Retrieve the status byte for a specific user. * @@ -4568,16 +2879,12 @@ * Command: GetUserStatus * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetUserStatus(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_USER_STATUS_COMMAND_ID, \ - "v", \ - userId); +#define emberAfFillCommandDoorLockClusterGetUserStatus(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_STATUS_COMMAND_ID, "v", userId); - -/** @brief Set the schedule of days during the week that the associated user based on the user ID will have access to the lock and will be able to operate it. +/** @brief Set the schedule of days during the week that the associated user based on the user ID will have access to the lock and + * will be able to operate it. * * Cluster: Door Lock, Provides an interface into a generic way to secure a door. * Command: SetWeekdaySchedule @@ -4589,26 +2896,11 @@ * @param endHour uint8_t * @param endMinute uint8_t */ -#define emberAfFillCommandDoorLockClusterSetWeekdaySchedule(scheduleId, \ - userId, \ - daysMask, \ - startHour, \ - startMinute, \ - endHour, \ - endMinute) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID, \ - "uvuuuuu", \ - scheduleId, \ - userId, \ - daysMask, \ - startHour, \ - startMinute, \ - endHour, \ - endMinute); - +#define emberAfFillCommandDoorLockClusterSetWeekdaySchedule(scheduleId, userId, daysMask, startHour, startMinute, endHour, \ + endMinute) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID, "uvuuuuu", scheduleId, userId, daysMask, startHour, \ + startMinute, endHour, endMinute); /** @brief Retrieve a weekday schedule for doorlock user activation for a specific schedule id and user id. * @@ -4617,16 +2909,9 @@ * @param scheduleId uint8_t * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetWeekdaySchedule(scheduleId, \ - userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID, \ - "uv", \ - scheduleId, \ - userId); - +#define emberAfFillCommandDoorLockClusterGetWeekdaySchedule(scheduleId, userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID, "uv", scheduleId, userId); /** @brief Clear a weekday schedule for doorlock user activation for a specific schedule id and user id. * @@ -4635,16 +2920,9 @@ * @param scheduleId uint8_t * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterClearWeekdaySchedule(scheduleId, \ - userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID, \ - "uv", \ - scheduleId, \ - userId); - +#define emberAfFillCommandDoorLockClusterClearWeekdaySchedule(scheduleId, userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID, "uv", scheduleId, userId); /** @brief Set a door lock user id activation schedule according to a specific absolute local start and end time * @@ -4655,20 +2933,9 @@ * @param localStartTime uint32_t * @param localEndTime uint32_t */ -#define emberAfFillCommandDoorLockClusterSetYeardaySchedule(scheduleId, \ - userId, \ - localStartTime, \ - localEndTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID, \ - "uvww", \ - scheduleId, \ - userId, \ - localStartTime, \ - localEndTime); - +#define emberAfFillCommandDoorLockClusterSetYeardaySchedule(scheduleId, userId, localStartTime, localEndTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID, "uvww", scheduleId, userId, localStartTime, localEndTime); /** @brief Retrieve a yearday schedule for a specific scheduleId and userId * @@ -4677,16 +2944,9 @@ * @param scheduleId uint8_t * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetYeardaySchedule(scheduleId, \ - userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID, \ - "uv", \ - scheduleId, \ - userId); - +#define emberAfFillCommandDoorLockClusterGetYeardaySchedule(scheduleId, userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID, "uv", scheduleId, userId); /** @brief Clear a yearday schedule for a specific scheduleId and userId * @@ -4695,16 +2955,9 @@ * @param scheduleId uint8_t * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterClearYeardaySchedule(scheduleId, \ - userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID, \ - "uv", \ - scheduleId, \ - userId); - +#define emberAfFillCommandDoorLockClusterClearYeardaySchedule(scheduleId, userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID, "uv", scheduleId, userId); /** @brief Set the holiday schedule for a specific user * @@ -4715,20 +2968,10 @@ * @param localEndTime uint32_t * @param operatingModeDuringHoliday uint8_t */ -#define emberAfFillCommandDoorLockClusterSetHolidaySchedule(scheduleId, \ - localStartTime, \ - localEndTime, \ - operatingModeDuringHoliday) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID, \ - "uwwu", \ - scheduleId, \ - localStartTime, \ - localEndTime, \ - operatingModeDuringHoliday); - +#define emberAfFillCommandDoorLockClusterSetHolidaySchedule(scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID, "uwwu", scheduleId, localStartTime, localEndTime, \ + operatingModeDuringHoliday); /** @brief Retrieve a holiday schedule for a specific scheduleId * @@ -4736,14 +2979,9 @@ * Command: GetHolidaySchedule * @param scheduleId uint8_t */ -#define emberAfFillCommandDoorLockClusterGetHolidaySchedule(scheduleId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID, \ - "u", \ - scheduleId); - +#define emberAfFillCommandDoorLockClusterGetHolidaySchedule(scheduleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID, "u", scheduleId); /** @brief Clear a holiday schedule for a specific scheduleId * @@ -4751,14 +2989,9 @@ * Command: ClearHolidaySchedule * @param scheduleId uint8_t */ -#define emberAfFillCommandDoorLockClusterClearHolidaySchedule(scheduleId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID, \ - "u", \ - scheduleId); - +#define emberAfFillCommandDoorLockClusterClearHolidaySchedule(scheduleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID, "u", scheduleId); /** @brief Set the type value for a user based on user ID. * @@ -4767,16 +3000,9 @@ * @param userId uint16_t * @param userType uint8_t */ -#define emberAfFillCommandDoorLockClusterSetUserType(userId, \ - userType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_USER_TYPE_COMMAND_ID, \ - "vu", \ - userId, \ - userType); - +#define emberAfFillCommandDoorLockClusterSetUserType(userId, userType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_TYPE_COMMAND_ID, "vu", userId, userType); /** @brief Retrieve the type for a specific user based on the user ID. * @@ -4784,14 +3010,9 @@ * Command: GetUserType * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetUserType(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_USER_TYPE_COMMAND_ID, \ - "v", \ - userId); - +#define emberAfFillCommandDoorLockClusterGetUserType(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_TYPE_COMMAND_ID, "v", userId); /** @brief Set the PIN for a specified user id. * @@ -4802,20 +3023,9 @@ * @param userType uint8_t * @param id uint8_t* */ -#define emberAfFillCommandDoorLockClusterSetRfid(userId, \ - userStatus, \ - userType, \ - id) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_RFID_COMMAND_ID, \ - "vuus", \ - userId, \ - userStatus, \ - userType, \ - id); - +#define emberAfFillCommandDoorLockClusterSetRfid(userId, userStatus, userType, id) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_RFID_COMMAND_ID, "vuus", userId, userStatus, userType, id); /** @brief Retrieve RFID ID information for a user with a specific user ID. * @@ -4823,14 +3033,9 @@ * Command: GetRfid * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterGetRfid(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_RFID_COMMAND_ID, \ - "v", \ - userId); - +#define emberAfFillCommandDoorLockClusterGetRfid(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_RFID_COMMAND_ID, "v", userId); /** @brief Clear the RFID ID for a user with a specific user ID * @@ -4838,27 +3043,18 @@ * Command: ClearRfid * @param userId uint16_t */ -#define emberAfFillCommandDoorLockClusterClearRfid(userId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_RFID_COMMAND_ID, \ - "v", \ - userId); - +#define emberAfFillCommandDoorLockClusterClearRfid(userId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_RFID_COMMAND_ID, "v", userId); /** @brief Clear all RFID ID codes on the lock for all users. * * Cluster: Door Lock, Provides an interface into a generic way to secure a door. * Command: ClearAllRfids */ -#define emberAfFillCommandDoorLockClusterClearAllRfids() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_ALL_RFIDS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDoorLockClusterClearAllRfids() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_RFIDS_COMMAND_ID, ""); /** @brief Indicates lock success or failure * @@ -4866,14 +3062,9 @@ * Command: LockDoorResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterLockDoorResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterLockDoorResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID, "u", status); /** @brief Indicates unlock success or failure * @@ -4881,14 +3072,9 @@ * Command: UnlockDoorResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterUnlockDoorResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterUnlockDoorResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID, "u", status); /** @brief Response provided to the toggle command, indicates whether the toggle was successful or not. * @@ -4896,29 +3082,20 @@ * Command: ToggleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterToggleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_TOGGLE_RESPONSE_COMMAND_ID, \ - "u", \ - status); +#define emberAfFillCommandDoorLockClusterToggleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_TOGGLE_RESPONSE_COMMAND_ID, "u", status); - -/** @brief Response provided to unlock with specific timeout. This command indicates whether the unlock command was successful or not. +/** @brief Response provided to unlock with specific timeout. This command indicates whether the unlock command was successful or + * not. * * Cluster: Door Lock, Provides an interface into a generic way to secure a door. * Command: UnlockWithTimeoutResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterUnlockWithTimeoutResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterUnlockWithTimeoutResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the specific log record requested. * @@ -4932,26 +3109,11 @@ * @param userId uint16_t * @param pin uint8_t* */ -#define emberAfFillCommandDoorLockClusterGetLogRecordResponse(logEntryId, \ - timestamp, \ - eventType, \ - source, \ - eventIdOrAlarmCode, \ - userId, \ - pin) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID, \ - "vwuuuvs", \ - logEntryId, \ - timestamp, \ - eventType, \ - source, \ - eventIdOrAlarmCode, \ - userId, \ - pin); - +#define emberAfFillCommandDoorLockClusterGetLogRecordResponse(logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, \ + userId, pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID, "vwuuuvs", logEntryId, timestamp, eventType, source, \ + eventIdOrAlarmCode, userId, pin); /** @brief Indicates whether the setting of the PIN was successful or not. * @@ -4959,14 +3121,9 @@ * Command: SetPinResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetPinResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_PIN_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetPinResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_PIN_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the PIN requested according to the user ID passed. * @@ -4977,20 +3134,9 @@ * @param userType uint8_t * @param pin uint8_t* */ -#define emberAfFillCommandDoorLockClusterGetPinResponse(userId, \ - userStatus, \ - userType, \ - pin) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_PIN_RESPONSE_COMMAND_ID, \ - "vuus", \ - userId, \ - userStatus, \ - userType, \ - pin); - +#define emberAfFillCommandDoorLockClusterGetPinResponse(userId, userStatus, userType, pin) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_PIN_RESPONSE_COMMAND_ID, "vuus", userId, userStatus, userType, pin); /** @brief Returns success or failure depending on whether the PIN was cleared or not. * @@ -4998,14 +3144,9 @@ * Command: ClearPinResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearPinResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearPinResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns success or failure depending on whether the PINs were cleared or not. * @@ -5013,14 +3154,9 @@ * Command: ClearAllPinsResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearAllPinsResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearAllPinsResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns success or failure depending on whether the user status was set or not. * @@ -5028,14 +3164,9 @@ * Command: SetUserStatusResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetUserStatusResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetUserStatusResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the user status. * @@ -5044,16 +3175,9 @@ * @param userId uint16_t * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterGetUserStatusResponse(userId, \ - status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID, \ - "vu", \ - userId, \ - status); - +#define emberAfFillCommandDoorLockClusterGetUserStatusResponse(userId, status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID, "vu", userId, status); /** @brief Returns the status of setting the weekday schedule * @@ -5061,14 +3185,9 @@ * Command: SetWeekdayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetWeekdayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetWeekdayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the weekday schedule requested. * @@ -5083,28 +3202,11 @@ * @param endHour uint8_t * @param endMinute uint8_t */ -#define emberAfFillCommandDoorLockClusterGetWeekdayScheduleResponse(scheduleId, \ - userId, \ - status, \ - daysMask, \ - startHour, \ - startMinute, \ - endHour, \ - endMinute) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "uvuuuuuu", \ - scheduleId, \ - userId, \ - status, \ - daysMask, \ - startHour, \ - startMinute, \ - endHour, \ - endMinute); - +#define emberAfFillCommandDoorLockClusterGetWeekdayScheduleResponse(scheduleId, userId, status, daysMask, startHour, startMinute, \ + endHour, endMinute) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, "uvuuuuuu", scheduleId, userId, status, daysMask, \ + startHour, startMinute, endHour, endMinute); /** @brief Returns the status of clearing the weekday schedule * @@ -5112,14 +3214,9 @@ * Command: ClearWeekdayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearWeekdayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearWeekdayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns success or failure depending on whether the yearday schedule was set or not. * @@ -5127,14 +3224,9 @@ * Command: SetYeardayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetYeardayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetYeardayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the yearday schedule requested * @@ -5146,22 +3238,10 @@ * @param localStartTime uint32_t * @param localEndTime uint32_t */ -#define emberAfFillCommandDoorLockClusterGetYeardayScheduleResponse(scheduleId, \ - userId, \ - status, \ - localStartTime, \ - localEndTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "uvuww", \ - scheduleId, \ - userId, \ - status, \ - localStartTime, \ - localEndTime); - +#define emberAfFillCommandDoorLockClusterGetYeardayScheduleResponse(scheduleId, userId, status, localStartTime, localEndTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, "uvuww", scheduleId, userId, status, localStartTime, \ + localEndTime); /** @brief Returns success or failure depending on whether the yearday schedule was removed or not. * @@ -5169,14 +3249,9 @@ * Command: ClearYeardayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearYeardayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearYeardayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns success or failure depending on whether the holiday schedule was set or not. * @@ -5184,14 +3259,9 @@ * Command: SetHolidayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetHolidayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetHolidayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the holiday schedule requested * @@ -5203,22 +3273,11 @@ * @param localEndTime uint32_t * @param operatingModeDuringHoliday uint8_t */ -#define emberAfFillCommandDoorLockClusterGetHolidayScheduleResponse(scheduleId, \ - status, \ - localStartTime, \ - localEndTime, \ - operatingModeDuringHoliday) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "uuwwu", \ - scheduleId, \ - status, \ - localStartTime, \ - localEndTime, \ - operatingModeDuringHoliday); - +#define emberAfFillCommandDoorLockClusterGetHolidayScheduleResponse(scheduleId, status, localStartTime, localEndTime, \ + operatingModeDuringHoliday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, "uuwwu", scheduleId, status, localStartTime, \ + localEndTime, operatingModeDuringHoliday); /** @brief Returns success or failure depending on whether the holiday schedule was removed or not. * @@ -5226,14 +3285,9 @@ * Command: ClearHolidayScheduleResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearHolidayScheduleResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearHolidayScheduleResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID, "u", status); /** @brief returns success or failure depending on whether the user type was set or not. * @@ -5241,14 +3295,9 @@ * Command: SetUserTypeResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetUserTypeResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetUserTypeResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the user type for the user ID requested. * @@ -5257,16 +3306,9 @@ * @param userId uint16_t * @param userType uint8_t */ -#define emberAfFillCommandDoorLockClusterGetUserTypeResponse(userId, \ - userType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID, \ - "vu", \ - userId, \ - userType); - +#define emberAfFillCommandDoorLockClusterGetUserTypeResponse(userId, userType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID, "vu", userId, userType); /** @brief Indicates whether the setting of the RFID ID was successful or not. * @@ -5274,14 +3316,9 @@ * Command: SetRfidResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterSetRfidResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_SET_RFID_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterSetRfidResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_SET_RFID_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns the RFID ID requested according to the user ID passed. * @@ -5292,20 +3329,9 @@ * @param userType uint8_t * @param rfid uint8_t* */ -#define emberAfFillCommandDoorLockClusterGetRfidResponse(userId, \ - userStatus, \ - userType, \ - rfid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_GET_RFID_RESPONSE_COMMAND_ID, \ - "vuus", \ - userId, \ - userStatus, \ - userType, \ - rfid); - +#define emberAfFillCommandDoorLockClusterGetRfidResponse(userId, userStatus, userType, rfid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_GET_RFID_RESPONSE_COMMAND_ID, "vuus", userId, userStatus, userType, rfid); /** @brief Returns success or failure depending on whether the RFID ID was cleared or not. * @@ -5313,14 +3339,9 @@ * Command: ClearRfidResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearRfidResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearRfidResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID, "u", status); /** @brief Returns success or failure depending on whether the RFID IDs were cleared or not. * @@ -5328,14 +3349,9 @@ * Command: ClearAllRfidsResponse * @param status uint8_t */ -#define emberAfFillCommandDoorLockClusterClearAllRfidsResponse(status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID, \ - "u", \ - status); - +#define emberAfFillCommandDoorLockClusterClearAllRfidsResponse(status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID, "u", status); /** @brief Indicates that an operation event has taken place. Includes the associated event information. * @@ -5348,24 +3364,10 @@ * @param timeStamp uint32_t * @param data uint8_t* */ -#define emberAfFillCommandDoorLockClusterOperationEventNotification(source, \ - eventCode, \ - userId, \ - pin, \ - timeStamp, \ - data) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID, \ - "uuvsws", \ - source, \ - eventCode, \ - userId, \ - pin, \ - timeStamp, \ - data); - +#define emberAfFillCommandDoorLockClusterOperationEventNotification(source, eventCode, userId, pin, timeStamp, data) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID, "uuvsws", source, eventCode, userId, pin, timeStamp, \ + data); /** @brief Indicates that a programming event has taken place. Includes the associated programming event information. * @@ -5380,32 +3382,14 @@ * @param timeStamp uint32_t * @param data uint8_t* */ -#define emberAfFillCommandDoorLockClusterProgrammingEventNotification(source, \ - eventCode, \ - userId, \ - pin, \ - userType, \ - userStatus, \ - timeStamp, \ - data) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DOOR_LOCK_CLUSTER_ID, \ - ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID, \ - "uuvsuuws", \ - source, \ - eventCode, \ - userId, \ - pin, \ - userType, \ - userStatus, \ - timeStamp, \ - data); - +#define emberAfFillCommandDoorLockClusterProgrammingEventNotification(source, eventCode, userId, pin, userType, userStatus, \ + timeStamp, data) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DOOR_LOCK_CLUSTER_ID, \ + ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID, "uuvsuuws", source, eventCode, userId, pin, userType, \ + userStatus, timeStamp, data); /** @} END Door Lock Commands */ - /** @name Window Covering Commands */ // @{ /** @brief Moves window covering to InstalledOpenLimit - Lift and InstalledOpenLimit - Tilt @@ -5413,39 +3397,27 @@ * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. * Command: WindowCoveringUpOpen */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringUpOpen() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID, \ - ""); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringUpOpen() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID, ""); /** @brief Moves window covering to InstalledClosedLimit - Lift and InstalledCloseLimit - Tilt * * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. * Command: WindowCoveringDownClose */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringDownClose() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringDownClose() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID, ""); /** @brief Stop any adjusting of window covering * * Cluster: Window Covering, Provides an interface for controlling and adjusting automatic window coverings. * Command: WindowCoveringStop */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringStop() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_STOP_COMMAND_ID, \ - ""); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_STOP_COMMAND_ID, ""); /** @brief Goto lift value specified * @@ -5453,14 +3425,9 @@ * Command: WindowCoveringGoToLiftValue * @param liftValue uint16_t */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftValue(liftValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID, \ - "v", \ - liftValue); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftValue(liftValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID, "v", liftValue); /** @brief Goto lift percentage specified * @@ -5468,14 +3435,9 @@ * Command: WindowCoveringGoToLiftPercentage * @param percentageLiftValue uint8_t */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftPercentage(percentageLiftValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID, \ - "u", \ - percentageLiftValue); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToLiftPercentage(percentageLiftValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID, "u", percentageLiftValue); /** @brief Goto tilt value specified * @@ -5483,14 +3445,9 @@ * Command: WindowCoveringGoToTiltValue * @param tiltValue uint16_t */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltValue(tiltValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID, \ - "v", \ - tiltValue); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltValue(tiltValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID, "v", tiltValue); /** @brief Goto tilt percentage specified * @@ -5498,18 +3455,12 @@ * Command: WindowCoveringGoToTiltPercentage * @param percentageTiltValue uint8_t */ -#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltPercentage(percentageTiltValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_WINDOW_COVERING_CLUSTER_ID, \ - ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID, \ - "u", \ - percentageTiltValue); - +#define emberAfFillCommandWindowCoveringClusterWindowCoveringGoToTiltPercentage(percentageTiltValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_WINDOW_COVERING_CLUSTER_ID, \ + ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID, "u", percentageTiltValue); /** @} END Window Covering Commands */ - /** @name Barrier Control Commands */ // @{ /** @brief Command to instruct a barrier to go to a percent open state. @@ -5518,36 +3469,25 @@ * Command: BarrierControlGoToPercent * @param percentOpen uint8_t */ -#define emberAfFillCommandBarrierControlClusterBarrierControlGoToPercent(percentOpen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BARRIER_CONTROL_CLUSTER_ID, \ - ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID, \ - "u", \ - percentOpen); - +#define emberAfFillCommandBarrierControlClusterBarrierControlGoToPercent(percentOpen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BARRIER_CONTROL_CLUSTER_ID, \ + ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID, "u", percentOpen); /** @brief Command that instructs the barrier to stop moving. * * Cluster: Barrier Control, This cluster provides control of a barrier (garage door). * Command: BarrierControlStop */ -#define emberAfFillCommandBarrierControlClusterBarrierControlStop() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BARRIER_CONTROL_CLUSTER_ID, \ - ZCL_BARRIER_CONTROL_STOP_COMMAND_ID, \ - ""); - +#define emberAfFillCommandBarrierControlClusterBarrierControlStop() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BARRIER_CONTROL_CLUSTER_ID, \ + ZCL_BARRIER_CONTROL_STOP_COMMAND_ID, ""); /** @} END Barrier Control Commands */ - /** @name Pump Configuration and Control Commands */ // @{ /** @} END Pump Configuration and Control Commands */ - /** @name Thermostat Commands */ // @{ /** @brief Command description for SetpointRaiseLower @@ -5557,16 +3497,9 @@ * @param mode uint8_t * @param amount int8_t */ -#define emberAfFillCommandThermostatClusterSetpointRaiseLower(mode, \ - amount) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID, \ - "uu", \ - mode, \ - amount); - +#define emberAfFillCommandThermostatClusterSetpointRaiseLower(mode, amount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID, "uu", mode, amount); /** @brief Command description for SetWeeklySchedule * @@ -5578,22 +3511,11 @@ * @param payload uint8_t* * @param payloadLen uint16_t */ -#define emberAfFillCommandThermostatClusterSetWeeklySchedule(numberOfTransitionsForSequence, \ - dayOfWeekForSequence, \ - modeForSequence, \ - payload, \ - payloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID, \ - "uuub", \ - numberOfTransitionsForSequence, \ - dayOfWeekForSequence, \ - modeForSequence, \ - payload, \ - payloadLen); - +#define emberAfFillCommandThermostatClusterSetWeeklySchedule(numberOfTransitionsForSequence, dayOfWeekForSequence, \ + modeForSequence, payload, payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID, "uuub", numberOfTransitionsForSequence, dayOfWeekForSequence, \ + modeForSequence, payload, payloadLen); /** @brief Command description for GetWeeklySchedule * @@ -5602,42 +3524,27 @@ * @param daysToReturn uint8_t * @param modeToReturn uint8_t */ -#define emberAfFillCommandThermostatClusterGetWeeklySchedule(daysToReturn, \ - modeToReturn) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID, \ - "uu", \ - daysToReturn, \ - modeToReturn); - +#define emberAfFillCommandThermostatClusterGetWeeklySchedule(daysToReturn, modeToReturn) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID, "uu", daysToReturn, modeToReturn); /** @brief The Clear Weekly Schedule command is used to clear the weekly schedule. * * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. * Command: ClearWeeklySchedule */ -#define emberAfFillCommandThermostatClusterClearWeeklySchedule() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandThermostatClusterClearWeeklySchedule() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID, ""); /** @brief The Get Relay Status Log command is used to query the thermostat internal relay status log. * * Cluster: Thermostat, An interface for configuring and controlling the functionality of a thermostat. * Command: GetRelayStatusLog */ -#define emberAfFillCommandThermostatClusterGetRelayStatusLog() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID, \ - ""); - +#define emberAfFillCommandThermostatClusterGetRelayStatusLog() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID, ""); /** @brief The Current Weekly Schedule Command is sent from the server in response to the Get Weekly Schedule Command. * @@ -5649,22 +3556,11 @@ * @param payload uint8_t* * @param payloadLen uint16_t */ -#define emberAfFillCommandThermostatClusterCurrentWeeklySchedule(numberOfTransitionsForSequence, \ - dayOfWeekForSequence, \ - modeForSequence, \ - payload, \ - payloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_CURRENT_WEEKLY_SCHEDULE_COMMAND_ID, \ - "uuub", \ - numberOfTransitionsForSequence, \ - dayOfWeekForSequence, \ - modeForSequence, \ - payload, \ - payloadLen); - +#define emberAfFillCommandThermostatClusterCurrentWeeklySchedule(numberOfTransitionsForSequence, dayOfWeekForSequence, \ + modeForSequence, payload, payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_CURRENT_WEEKLY_SCHEDULE_COMMAND_ID, "uuub", numberOfTransitionsForSequence, \ + dayOfWeekForSequence, modeForSequence, payload, payloadLen); /** @brief This command is sent from the thermostat cluster server in response to the Get Relay Status Log. * @@ -5677,43 +3573,26 @@ * @param setpoint int16_t * @param unreadEntries uint16_t */ -#define emberAfFillCommandThermostatClusterRelayStatusLog(timeOfDay, \ - relayStatus, \ - localTemperature, \ - humidityInPercentage, \ - setpoint, \ - unreadEntries) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_THERMOSTAT_CLUSTER_ID, \ - ZCL_RELAY_STATUS_LOG_COMMAND_ID, \ - "vvvuvv", \ - timeOfDay, \ - relayStatus, \ - localTemperature, \ - humidityInPercentage, \ - setpoint, \ - unreadEntries); - +#define emberAfFillCommandThermostatClusterRelayStatusLog(timeOfDay, relayStatus, localTemperature, humidityInPercentage, \ + setpoint, unreadEntries) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_THERMOSTAT_CLUSTER_ID, \ + ZCL_RELAY_STATUS_LOG_COMMAND_ID, "vvvuvv", timeOfDay, relayStatus, localTemperature, \ + humidityInPercentage, setpoint, unreadEntries); /** @} END Thermostat Commands */ - /** @name Fan Control Commands */ // @{ /** @} END Fan Control Commands */ - /** @name Dehumidification Control Commands */ // @{ /** @} END Dehumidification Control Commands */ - /** @name Thermostat User Interface Configuration Commands */ // @{ /** @} END Thermostat User Interface Configuration Commands */ - /** @name Color Control Commands */ // @{ /** @brief Move to specified hue. @@ -5726,22 +3605,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveToHue(hue, \ - direction, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_HUE_COMMAND_ID, \ - "uuvuu", \ - hue, \ - direction, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveToHue(hue, direction, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_HUE_COMMAND_ID, "uuvuu", hue, direction, transitionTime, optionsMask, optionsOverride); /** @brief Move hue up or down at specified rate. * @@ -5752,20 +3618,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveHue(moveMode, \ - rate, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_HUE_COMMAND_ID, \ - "uuuu", \ - moveMode, \ - rate, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveHue(moveMode, rate, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_HUE_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride); /** @brief Step hue up or down by specified size at specified rate. * @@ -5777,22 +3632,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterStepHue(stepMode, \ - stepSize, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_STEP_HUE_COMMAND_ID, \ - "uuuuu", \ - stepMode, \ - stepSize, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterStepHue(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_HUE_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, optionsOverride); /** @brief Move to specified saturation. * @@ -5803,20 +3645,10 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveToSaturation(saturation, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_SATURATION_COMMAND_ID, \ - "uvuu", \ - saturation, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveToSaturation(saturation, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_SATURATION_COMMAND_ID, "uvuu", saturation, transitionTime, optionsMask, \ + optionsOverride); /** @brief Move saturation up or down at specified rate. * @@ -5827,20 +3659,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveSaturation(moveMode, \ - rate, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_SATURATION_COMMAND_ID, \ - "uuuu", \ - moveMode, \ - rate, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveSaturation(moveMode, rate, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_SATURATION_COMMAND_ID, "uuuu", moveMode, rate, optionsMask, optionsOverride); /** @brief Step saturation up or down by specified size at specified rate. * @@ -5852,22 +3673,10 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterStepSaturation(stepMode, \ - stepSize, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_STEP_SATURATION_COMMAND_ID, \ - "uuuuu", \ - stepMode, \ - stepSize, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterStepSaturation(stepMode, stepSize, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_SATURATION_COMMAND_ID, "uuuuu", stepMode, stepSize, transitionTime, optionsMask, \ + optionsOverride); /** @brief Move to hue and saturation. * @@ -5879,22 +3688,10 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveToHueAndSaturation(hue, \ - saturation, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, \ - "uuvuu", \ - hue, \ - saturation, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveToHueAndSaturation(hue, saturation, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "uuvuu", hue, saturation, transitionTime, optionsMask, \ + optionsOverride); /** @brief Move to specified color. * @@ -5906,22 +3703,10 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveToColor(colorX, \ - colorY, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_COLOR_COMMAND_ID, \ - "vvvuu", \ - colorX, \ - colorY, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveToColor(colorX, colorY, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_COLOR_COMMAND_ID, "vvvuu", colorX, colorY, transitionTime, optionsMask, \ + optionsOverride); /** @brief Moves the color. * @@ -5932,20 +3717,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveColor(rateX, \ - rateY, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_COLOR_COMMAND_ID, \ - "vvuu", \ - rateX, \ - rateY, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveColor(rateX, rateY, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COLOR_COMMAND_ID, "vvuu", rateX, rateY, optionsMask, optionsOverride); /** @brief Steps the lighting to a specific color. * @@ -5957,22 +3731,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterStepColor(stepX, \ - stepY, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_STEP_COLOR_COMMAND_ID, \ - "vvvuu", \ - stepX, \ - stepY, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterStepColor(stepX, stepY, transitionTime, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COLOR_COMMAND_ID, "vvvuu", stepX, stepY, transitionTime, optionsMask, optionsOverride); /** @brief Move to a specific color temperature. * @@ -5983,20 +3744,11 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveToColorTemperature(colorTemperature, \ - transitionTime, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID, \ - "vvuu", \ - colorTemperature, \ - transitionTime, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveToColorTemperature(colorTemperature, transitionTime, optionsMask, \ + optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID, "vvuu", colorTemperature, transitionTime, optionsMask, \ + optionsOverride); /** @brief Command description for EnhancedMoveToHue * @@ -6006,18 +3758,9 @@ * @param direction uint8_t * @param transitionTime uint16_t */ -#define emberAfFillCommandColorControlClusterEnhancedMoveToHue(enhancedHue, \ - direction, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID, \ - "vuv", \ - enhancedHue, \ - direction, \ - transitionTime); - +#define emberAfFillCommandColorControlClusterEnhancedMoveToHue(enhancedHue, direction, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID, "vuv", enhancedHue, direction, transitionTime); /** @brief Command description for EnhancedMoveHue * @@ -6026,16 +3769,9 @@ * @param moveMode uint8_t * @param rate uint16_t */ -#define emberAfFillCommandColorControlClusterEnhancedMoveHue(moveMode, \ - rate) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_ENHANCED_MOVE_HUE_COMMAND_ID, \ - "uv", \ - moveMode, \ - rate); - +#define emberAfFillCommandColorControlClusterEnhancedMoveHue(moveMode, rate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_HUE_COMMAND_ID, "uv", moveMode, rate); /** @brief Command description for EnhancedStepHue * @@ -6045,18 +3781,9 @@ * @param stepSize uint16_t * @param transitionTime uint16_t */ -#define emberAfFillCommandColorControlClusterEnhancedStepHue(stepMode, \ - stepSize, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_ENHANCED_STEP_HUE_COMMAND_ID, \ - "uvv", \ - stepMode, \ - stepSize, \ - transitionTime); - +#define emberAfFillCommandColorControlClusterEnhancedStepHue(stepMode, stepSize, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_STEP_HUE_COMMAND_ID, "uvv", stepMode, stepSize, transitionTime); /** @brief Command description for EnhancedMoveToHueAndSaturation * @@ -6066,18 +3793,9 @@ * @param saturation uint8_t * @param transitionTime uint16_t */ -#define emberAfFillCommandColorControlClusterEnhancedMoveToHueAndSaturation(enhancedHue, \ - saturation, \ - transitionTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, \ - "vuv", \ - enhancedHue, \ - saturation, \ - transitionTime); - +#define emberAfFillCommandColorControlClusterEnhancedMoveToHueAndSaturation(enhancedHue, saturation, transitionTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID, "vuv", enhancedHue, saturation, transitionTime); /** @brief Command description for ColorLoopSet * @@ -6089,22 +3807,9 @@ * @param time uint16_t * @param startHue uint16_t */ -#define emberAfFillCommandColorControlClusterColorLoopSet(updateFlags, \ - action, \ - direction, \ - time, \ - startHue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_COLOR_LOOP_SET_COMMAND_ID, \ - "uuuvv", \ - updateFlags, \ - action, \ - direction, \ - time, \ - startHue); - +#define emberAfFillCommandColorControlClusterColorLoopSet(updateFlags, action, direction, time, startHue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_COLOR_LOOP_SET_COMMAND_ID, "uuuvv", updateFlags, action, direction, time, startHue); /** @brief Command description for StopMoveStep * @@ -6113,16 +3818,9 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterStopMoveStep(optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_STOP_MOVE_STEP_COMMAND_ID, \ - "uu", \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterStopMoveStep(optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STOP_MOVE_STEP_COMMAND_ID, "uu", optionsMask, optionsOverride); /** @brief Command description for MoveColorTemperature * @@ -6135,24 +3833,11 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterMoveColorTemperature(moveMode, \ - rate, \ - colorTemperatureMinimum, \ - colorTemperatureMaximum, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID, \ - "uvvvuu", \ - moveMode, \ - rate, \ - colorTemperatureMinimum, \ - colorTemperatureMaximum, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterMoveColorTemperature(moveMode, rate, colorTemperatureMinimum, \ + colorTemperatureMaximum, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID, "uvvvuu", moveMode, rate, colorTemperatureMinimum, \ + colorTemperatureMaximum, optionsMask, optionsOverride); /** @brief Command description for StepColorTemperature * @@ -6166,220 +3851,166 @@ * @param optionsMask uint8_t * @param optionsOverride uint8_t */ -#define emberAfFillCommandColorControlClusterStepColorTemperature(stepMode, \ - stepSize, \ - transitionTime, \ - colorTemperatureMinimum, \ - colorTemperatureMaximum, \ - optionsMask, \ - optionsOverride) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_COLOR_CONTROL_CLUSTER_ID, \ - ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID, \ - "uvvvvuu", \ - stepMode, \ - stepSize, \ - transitionTime, \ - colorTemperatureMinimum, \ - colorTemperatureMaximum, \ - optionsMask, \ - optionsOverride); - +#define emberAfFillCommandColorControlClusterStepColorTemperature(stepMode, stepSize, transitionTime, colorTemperatureMinimum, \ + colorTemperatureMaximum, optionsMask, optionsOverride) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_COLOR_CONTROL_CLUSTER_ID, \ + ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID, "uvvvvuu", stepMode, stepSize, transitionTime, \ + colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride); /** @} END Color Control Commands */ - /** @name Ballast Configuration Commands */ // @{ /** @} END Ballast Configuration Commands */ - /** @name Illuminance Measurement Commands */ // @{ /** @} END Illuminance Measurement Commands */ - /** @name Illuminance Level Sensing Commands */ // @{ /** @} END Illuminance Level Sensing Commands */ - /** @name Temperature Measurement Commands */ // @{ /** @} END Temperature Measurement Commands */ - /** @name Pressure Measurement Commands */ // @{ /** @} END Pressure Measurement Commands */ - /** @name Flow Measurement Commands */ // @{ /** @} END Flow Measurement Commands */ - /** @name Relative Humidity Measurement Commands */ // @{ /** @} END Relative Humidity Measurement Commands */ - /** @name Occupancy Sensing Commands */ // @{ /** @} END Occupancy Sensing Commands */ - /** @name Carbon Monoxide Concentration Measurement Commands */ // @{ /** @} END Carbon Monoxide Concentration Measurement Commands */ - /** @name Carbon Dioxide Concentration Measurement Commands */ // @{ /** @} END Carbon Dioxide Concentration Measurement Commands */ - /** @name Ethylene Concentration Measurement Commands */ // @{ /** @} END Ethylene Concentration Measurement Commands */ - /** @name Ethylene Oxide Concentration Measurement Commands */ // @{ /** @} END Ethylene Oxide Concentration Measurement Commands */ - /** @name Hydrogen Concentration Measurement Commands */ // @{ /** @} END Hydrogen Concentration Measurement Commands */ - /** @name Hydrogen Sulphide Concentration Measurement Commands */ // @{ /** @} END Hydrogen Sulphide Concentration Measurement Commands */ - /** @name Nitric Oxide Concentration Measurement Commands */ // @{ /** @} END Nitric Oxide Concentration Measurement Commands */ - /** @name Nitrogen Dioxide Concentration Measurement Commands */ // @{ /** @} END Nitrogen Dioxide Concentration Measurement Commands */ - /** @name Oxygen Concentration Measurement Commands */ // @{ /** @} END Oxygen Concentration Measurement Commands */ - /** @name Ozone Concentration Measurement Commands */ // @{ /** @} END Ozone Concentration Measurement Commands */ - /** @name Sulfur Dioxide Concentration Measurement Commands */ // @{ /** @} END Sulfur Dioxide Concentration Measurement Commands */ - /** @name Dissolved Oxygen Concentration Measurement Commands */ // @{ /** @} END Dissolved Oxygen Concentration Measurement Commands */ - /** @name Bromate Concentration Measurement Commands */ // @{ /** @} END Bromate Concentration Measurement Commands */ - /** @name Chloramines Concentration Measurement Commands */ // @{ /** @} END Chloramines Concentration Measurement Commands */ - /** @name Chlorine Concentration Measurement Commands */ // @{ /** @} END Chlorine Concentration Measurement Commands */ - /** @name Fecal coliform and E. Coli Concentration Measurement Commands */ // @{ /** @} END Fecal coliform and E. Coli Concentration Measurement Commands */ - /** @name Fluoride Concentration Measurement Commands */ // @{ /** @} END Fluoride Concentration Measurement Commands */ - /** @name Haloacetic Acids Concentration Measurement Commands */ // @{ /** @} END Haloacetic Acids Concentration Measurement Commands */ - /** @name Total Trihalomethanes Concentration Measurement Commands */ // @{ /** @} END Total Trihalomethanes Concentration Measurement Commands */ - /** @name Total Coliform Bacteria Concentration Measurement Commands */ // @{ /** @} END Total Coliform Bacteria Concentration Measurement Commands */ - /** @name Turbidity Concentration Measurement Commands */ // @{ /** @} END Turbidity Concentration Measurement Commands */ - /** @name Copper Concentration Measurement Commands */ // @{ /** @} END Copper Concentration Measurement Commands */ - /** @name Lead Concentration Measurement Commands */ // @{ /** @} END Lead Concentration Measurement Commands */ - /** @name Manganese Concentration Measurement Commands */ // @{ /** @} END Manganese Concentration Measurement Commands */ - /** @name Sulfate Concentration Measurement Commands */ // @{ /** @} END Sulfate Concentration Measurement Commands */ - /** @name Bromodichloromethane Concentration Measurement Commands */ // @{ /** @} END Bromodichloromethane Concentration Measurement Commands */ - /** @name Bromoform Concentration Measurement Commands */ // @{ /** @} END Bromoform Concentration Measurement Commands */ - /** @name Chlorodibromomethane Concentration Measurement Commands */ // @{ /** @} END Chlorodibromomethane Concentration Measurement Commands */ - /** @name Chloroform Concentration Measurement Commands */ // @{ /** @} END Chloroform Concentration Measurement Commands */ - /** @name Sodium Concentration Measurement Commands */ // @{ /** @} END Sodium Concentration Measurement Commands */ - /** @name IAS Zone Commands */ // @{ /** @brief Command description for zoneEnrollResponse @@ -6389,47 +4020,31 @@ * @param enrollResponseCode uint8_t * @param zoneId uint8_t */ -#define emberAfFillCommandIasZoneClusterZoneEnrollResponse(enrollResponseCode, \ - zoneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID, \ - "uu", \ - enrollResponseCode, \ - zoneId); - +#define emberAfFillCommandIasZoneClusterZoneEnrollResponse(enrollResponseCode, zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID, "uu", enrollResponseCode, zoneId); /** @brief Used to tell the IAS Zone server to commence normal operation mode * * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. * Command: InitiateNormalOperationMode */ -#define emberAfFillCommandIasZoneClusterInitiateNormalOperationMode() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID, \ - ""); +#define emberAfFillCommandIasZoneClusterInitiateNormalOperationMode() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID, ""); - -/** @brief Certain IAS Zone servers may have operational configurations that could be configured OTA or locally on the device. This command enables them to be remotely placed into a test mode so that the user or installer may configure their field of view, sensitivity, and other operational parameters. +/** @brief Certain IAS Zone servers may have operational configurations that could be configured OTA or locally on the device. This + * command enables them to be remotely placed into a test mode so that the user or installer may configure their field of view, + * sensitivity, and other operational parameters. * * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. * Command: InitiateTestMode * @param testModeDuration uint8_t * @param currentZoneSensitivityLevel uint8_t */ -#define emberAfFillCommandIasZoneClusterInitiateTestMode(testModeDuration, \ - currentZoneSensitivityLevel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_INITIATE_TEST_MODE_COMMAND_ID, \ - "uu", \ - testModeDuration, \ - currentZoneSensitivityLevel); - +#define emberAfFillCommandIasZoneClusterInitiateTestMode(testModeDuration, currentZoneSensitivityLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_TEST_MODE_COMMAND_ID, "uu", testModeDuration, currentZoneSensitivityLevel); /** @brief Command description for zoneStatusChangeNotification * @@ -6440,20 +4055,9 @@ * @param zoneId uint8_t * @param delay uint16_t */ -#define emberAfFillCommandIasZoneClusterZoneStatusChangeNotification(zoneStatus, \ - extendedStatus, \ - zoneId, \ - delay) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID, \ - "vuuv", \ - zoneStatus, \ - extendedStatus, \ - zoneId, \ - delay); - +#define emberAfFillCommandIasZoneClusterZoneStatusChangeNotification(zoneStatus, extendedStatus, zoneId, delay) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID, "vuuv", zoneStatus, extendedStatus, zoneId, delay); /** @brief Command description for zoneEnrollRequest * @@ -6462,46 +4066,31 @@ * @param zoneType uint16_t * @param manufacturerCode uint16_t */ -#define emberAfFillCommandIasZoneClusterZoneEnrollRequest(zoneType, \ - manufacturerCode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID, \ - "vv", \ - zoneType, \ - manufacturerCode); - +#define emberAfFillCommandIasZoneClusterZoneEnrollRequest(zoneType, manufacturerCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID, "vv", zoneType, manufacturerCode); /** @brief Confirms that the IAS Zone server has commenced normal operation mode. * * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. * Command: InitiateNormalOperationModeResponse */ -#define emberAfFillCommandIasZoneClusterInitiateNormalOperationModeResponse() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasZoneClusterInitiateNormalOperationModeResponse() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID, ""); -/** @brief Confirms that the IAS Zone server has commenced test mode and that the IAS Zone client should treat any Zone Status Change Notification commands received from the sending IAS Zone server as being in response to test events. +/** @brief Confirms that the IAS Zone server has commenced test mode and that the IAS Zone client should treat any Zone Status + * Change Notification commands received from the sending IAS Zone server as being in response to test events. * * Cluster: IAS Zone, Attributes and commands for IAS security zone devices. * Command: InitiateTestModeResponse */ -#define emberAfFillCommandIasZoneClusterInitiateTestModeResponse() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ZONE_CLUSTER_ID, \ - ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasZoneClusterInitiateTestModeResponse() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ZONE_CLUSTER_ID, \ + ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID, ""); /** @} END IAS Zone Commands */ - /** @name IAS ACE Commands */ // @{ /** @brief Command description for Arm @@ -6512,18 +4101,9 @@ * @param armDisarmCode uint8_t* * @param zoneId uint8_t */ -#define emberAfFillCommandIasAceClusterArm(armMode, \ - armDisarmCode, \ - zoneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_ARM_COMMAND_ID, \ - "usu", \ - armMode, \ - armDisarmCode, \ - zoneId); - +#define emberAfFillCommandIasAceClusterArm(armMode, armDisarmCode, zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ARM_COMMAND_ID, "usu", armMode, armDisarmCode, zoneId); /** @brief Command description for Bypass * @@ -6534,72 +4114,45 @@ * @param zoneIdsLen uint16_t * @param armDisarmCode uint8_t* */ -#define emberAfFillCommandIasAceClusterBypass(numberOfZones, \ - zoneIds, \ - zoneIdsLen, \ - armDisarmCode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_BYPASS_COMMAND_ID, \ - "ubs", \ - numberOfZones, \ - zoneIds, \ - zoneIdsLen, \ - armDisarmCode); - +#define emberAfFillCommandIasAceClusterBypass(numberOfZones, zoneIds, zoneIdsLen, armDisarmCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_BYPASS_COMMAND_ID, "ubs", numberOfZones, zoneIds, zoneIdsLen, armDisarmCode); /** @brief Command description for Emergency * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: Emergency */ -#define emberAfFillCommandIasAceClusterEmergency() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_EMERGENCY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterEmergency() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_EMERGENCY_COMMAND_ID, ""); /** @brief Command description for Fire * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: Fire */ -#define emberAfFillCommandIasAceClusterFire() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_FIRE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterFire() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_FIRE_COMMAND_ID, ""); /** @brief Command description for Panic * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: Panic */ -#define emberAfFillCommandIasAceClusterPanic() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_PANIC_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterPanic() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_PANIC_COMMAND_ID, ""); /** @brief Command description for GetZoneIdMap * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: GetZoneIdMap */ -#define emberAfFillCommandIasAceClusterGetZoneIdMap() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_ID_MAP_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterGetZoneIdMap() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_ID_MAP_COMMAND_ID, ""); /** @brief Command description for GetZoneInformation * @@ -6607,40 +4160,27 @@ * Command: GetZoneInformation * @param zoneId uint8_t */ -#define emberAfFillCommandIasAceClusterGetZoneInformation(zoneId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_INFORMATION_COMMAND_ID, \ - "u", \ - zoneId); - +#define emberAfFillCommandIasAceClusterGetZoneInformation(zoneId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_INFORMATION_COMMAND_ID, "u", zoneId); /** @brief Used by the ACE client to request an update to the status of the ACE server * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: GetPanelStatus */ -#define emberAfFillCommandIasAceClusterGetPanelStatus() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_PANEL_STATUS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterGetPanelStatus() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_PANEL_STATUS_COMMAND_ID, ""); /** @brief Used by the ACE client to retrieve the bypassed zones * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: GetBypassedZoneList */ -#define emberAfFillCommandIasAceClusterGetBypassedZoneList() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIasAceClusterGetBypassedZoneList() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID, ""); /** @brief Used by the ACE client to request an update to the zone status of the ACE server * @@ -6651,20 +4191,10 @@ * @param zoneStatusMaskFlag uint8_t * @param zoneStatusMask uint16_t */ -#define emberAfFillCommandIasAceClusterGetZoneStatus(startingZoneId, \ - maxNumberOfZoneIds, \ - zoneStatusMaskFlag, \ - zoneStatusMask) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_STATUS_COMMAND_ID, \ - "uuuv", \ - startingZoneId, \ - maxNumberOfZoneIds, \ - zoneStatusMaskFlag, \ - zoneStatusMask); - +#define emberAfFillCommandIasAceClusterGetZoneStatus(startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, zoneStatusMask) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_STATUS_COMMAND_ID, "uuuv", startingZoneId, maxNumberOfZoneIds, zoneStatusMaskFlag, \ + zoneStatusMask); /** @brief Command description for ArmResponse * @@ -6672,14 +4202,9 @@ * Command: ArmResponse * @param armNotification uint8_t */ -#define emberAfFillCommandIasAceClusterArmResponse(armNotification) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_ARM_RESPONSE_COMMAND_ID, \ - "u", \ - armNotification); - +#define emberAfFillCommandIasAceClusterArmResponse(armNotification) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ARM_RESPONSE_COMMAND_ID, "u", armNotification); /** @brief Command description for GetZoneIdMapResponse * @@ -6702,44 +4227,13 @@ * @param section14 uint16_t * @param section15 uint16_t */ -#define emberAfFillCommandIasAceClusterGetZoneIdMapResponse(section0, \ - section1, \ - section2, \ - section3, \ - section4, \ - section5, \ - section6, \ - section7, \ - section8, \ - section9, \ - section10, \ - section11, \ - section12, \ - section13, \ - section14, \ - section15) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID, \ - "vvvvvvvvvvvvvvvv", \ - section0, \ - section1, \ - section2, \ - section3, \ - section4, \ - section5, \ - section6, \ - section7, \ - section8, \ - section9, \ - section10, \ - section11, \ - section12, \ - section13, \ - section14, \ - section15); - +#define emberAfFillCommandIasAceClusterGetZoneIdMapResponse(section0, section1, section2, section3, section4, section5, section6, \ + section7, section8, section9, section10, section11, section12, \ + section13, section14, section15) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID, "vvvvvvvvvvvvvvvv", section0, section1, section2, section3, \ + section4, section5, section6, section7, section8, section9, section10, section11, section12, \ + section13, section14, section15); /** @brief Command description for GetZoneInformationResponse * @@ -6750,22 +4244,12 @@ * @param ieeeAddress uint8_t* * @param zoneLabel uint8_t* */ -#define emberAfFillCommandIasAceClusterGetZoneInformationResponse(zoneId, \ - zoneType, \ - ieeeAddress, \ - zoneLabel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_INFORMATION_RESPONSE_COMMAND_ID, \ - "uv8s", \ - zoneId, \ - zoneType, \ - ieeeAddress, \ - zoneLabel); +#define emberAfFillCommandIasAceClusterGetZoneInformationResponse(zoneId, zoneType, ieeeAddress, zoneLabel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_INFORMATION_RESPONSE_COMMAND_ID, "uv8s", zoneId, zoneType, ieeeAddress, zoneLabel); - -/** @brief This command updates ACE clients in the system of changes to zone status recorded by the ACE server (e.g., IAS CIE device). +/** @brief This command updates ACE clients in the system of changes to zone status recorded by the ACE server (e.g., IAS CIE + * device). * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: ZoneStatusChanged @@ -6774,22 +4258,12 @@ * @param audibleNotification uint8_t * @param zoneLabel uint8_t* */ -#define emberAfFillCommandIasAceClusterZoneStatusChanged(zoneId, \ - zoneStatus, \ - audibleNotification, \ - zoneLabel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_ZONE_STATUS_CHANGED_COMMAND_ID, \ - "uvus", \ - zoneId, \ - zoneStatus, \ - audibleNotification, \ - zoneLabel); - +#define emberAfFillCommandIasAceClusterZoneStatusChanged(zoneId, zoneStatus, audibleNotification, zoneLabel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_ZONE_STATUS_CHANGED_COMMAND_ID, "uvus", zoneId, zoneStatus, audibleNotification, zoneLabel); -/** @brief This command updates ACE clients in the system of changes to panel status recorded by the ACE server (e.g., IAS CIE device). +/** @brief This command updates ACE clients in the system of changes to panel status recorded by the ACE server (e.g., IAS CIE + * device). * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: PanelStatusChanged @@ -6798,22 +4272,13 @@ * @param audibleNotification uint8_t * @param alarmStatus uint8_t */ -#define emberAfFillCommandIasAceClusterPanelStatusChanged(panelStatus, \ - secondsRemaining, \ - audibleNotification, \ - alarmStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_PANEL_STATUS_CHANGED_COMMAND_ID, \ - "uuuu", \ - panelStatus, \ - secondsRemaining, \ - audibleNotification, \ - alarmStatus); - +#define emberAfFillCommandIasAceClusterPanelStatusChanged(panelStatus, secondsRemaining, audibleNotification, alarmStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_PANEL_STATUS_CHANGED_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, audibleNotification, \ + alarmStatus); -/** @brief Command updates requesting IAS ACE clients in the system of changes to the security panel status recorded by the ACE server. +/** @brief Command updates requesting IAS ACE clients in the system of changes to the security panel status recorded by the ACE + * server. * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: GetPanelStatusResponse @@ -6822,20 +4287,10 @@ * @param audibleNotification uint8_t * @param alarmStatus uint8_t */ -#define emberAfFillCommandIasAceClusterGetPanelStatusResponse(panelStatus, \ - secondsRemaining, \ - audibleNotification, \ - alarmStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID, \ - "uuuu", \ - panelStatus, \ - secondsRemaining, \ - audibleNotification, \ - alarmStatus); - +#define emberAfFillCommandIasAceClusterGetPanelStatusResponse(panelStatus, secondsRemaining, audibleNotification, alarmStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID, "uuuu", panelStatus, secondsRemaining, \ + audibleNotification, alarmStatus); /** @brief Sets the list of bypassed zones on the IAS ACE client * @@ -6845,18 +4300,9 @@ * @param zoneIds uint8_t* * @param zoneIdsLen uint16_t */ -#define emberAfFillCommandIasAceClusterSetBypassedZoneList(numberOfZones, \ - zoneIds, \ - zoneIdsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID, \ - "ub", \ - numberOfZones, \ - zoneIds, \ - zoneIdsLen); - +#define emberAfFillCommandIasAceClusterSetBypassedZoneList(numberOfZones, zoneIds, zoneIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID, "ub", numberOfZones, zoneIds, zoneIdsLen); /** @brief Provides the response of the security panel to the request from the IAS ACE client to bypass zones via a Bypass command. * @@ -6866,20 +4312,12 @@ * @param bypassResult uint8_t* * @param bypassResultLen uint16_t */ -#define emberAfFillCommandIasAceClusterBypassResponse(numberOfZones, \ - bypassResult, \ - bypassResultLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_BYPASS_RESPONSE_COMMAND_ID, \ - "ub", \ - numberOfZones, \ - bypassResult, \ - bypassResultLen); +#define emberAfFillCommandIasAceClusterBypassResponse(numberOfZones, bypassResult, bypassResultLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_BYPASS_RESPONSE_COMMAND_ID, "ub", numberOfZones, bypassResult, bypassResultLen); - -/** @brief This command updates requesting IAS ACE clients in the system of changes to the IAS Zone server statuses recorded by the ACE server (e.g., IAS CIE device). +/** @brief This command updates requesting IAS ACE clients in the system of changes to the IAS Zone server statuses recorded by the + * ACE server (e.g., IAS CIE device). * * Cluster: IAS ACE, Attributes and commands for IAS Ancillary Control Equipment. * Command: GetZoneStatusResponse @@ -6888,24 +4326,14 @@ * @param zoneStatusResult uint8_t* * @param zoneStatusResultLen uint16_t */ -#define emberAfFillCommandIasAceClusterGetZoneStatusResponse(zoneStatusComplete, \ - numberOfZones, \ - zoneStatusResult, \ - zoneStatusResultLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_IAS_ACE_CLUSTER_ID, \ - ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID, \ - "uub", \ - zoneStatusComplete, \ - numberOfZones, \ - zoneStatusResult, \ - zoneStatusResultLen); - +#define emberAfFillCommandIasAceClusterGetZoneStatusResponse(zoneStatusComplete, numberOfZones, zoneStatusResult, \ + zoneStatusResultLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_IAS_ACE_CLUSTER_ID, \ + ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID, "uub", zoneStatusComplete, numberOfZones, zoneStatusResult, \ + zoneStatusResultLen); /** @} END IAS ACE Commands */ - /** @name IAS WD Commands */ // @{ /** @brief Command description for StartWarning @@ -6917,20 +4345,9 @@ * @param strobeDutyCycle uint8_t * @param strobeLevel uint8_t */ -#define emberAfFillCommandIasWdClusterStartWarning(warningInfo, \ - warningDuration, \ - strobeDutyCycle, \ - strobeLevel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_WD_CLUSTER_ID, \ - ZCL_START_WARNING_COMMAND_ID, \ - "uvuu", \ - warningInfo, \ - warningDuration, \ - strobeDutyCycle, \ - strobeLevel); - +#define emberAfFillCommandIasWdClusterStartWarning(warningInfo, warningDuration, strobeDutyCycle, strobeLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_WD_CLUSTER_ID, \ + ZCL_START_WARNING_COMMAND_ID, "uvuu", warningInfo, warningDuration, strobeDutyCycle, strobeLevel); /** @brief Command description for Squawk * @@ -6938,112 +4355,82 @@ * Command: Squawk * @param squawkInfo uint8_t */ -#define emberAfFillCommandIasWdClusterSquawk(squawkInfo) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_IAS_WD_CLUSTER_ID, \ - ZCL_SQUAWK_COMMAND_ID, \ - "u", \ - squawkInfo); - +#define emberAfFillCommandIasWdClusterSquawk(squawkInfo) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_IAS_WD_CLUSTER_ID, \ + ZCL_SQUAWK_COMMAND_ID, "u", squawkInfo); /** @} END IAS WD Commands */ - /** @name Generic Tunnel Commands */ // @{ -/** @brief This command is generated when an application wishes to find the ZigBee address (node, endpoint) of the Generic Tunnel server cluster with a given ProtocolAddress attribute. The command is typically multicast to a group of inter-communicating Generic Tunnel clusters +/** @brief This command is generated when an application wishes to find the ZigBee address (node, endpoint) of the Generic Tunnel + * server cluster with a given ProtocolAddress attribute. The command is typically multicast to a group of inter-communicating + * Generic Tunnel clusters * * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. * Command: MatchProtocolAddress * @param protocolAddress uint8_t* */ -#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddress(protocolAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ - ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, \ - "s", \ - protocolAddress); - +#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddress(protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID, "s", protocolAddress); -/** @brief This command is generated upon receipt of a Match Protocol Address command to indicate that the Protocol Address was successfully matched. +/** @brief This command is generated upon receipt of a Match Protocol Address command to indicate that the Protocol Address was + * successfully matched. * * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. * Command: MatchProtocolAddressResponse * @param deviceIeeeAddress uint8_t* * @param protocolAddress uint8_t* */ -#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddressResponse(deviceIeeeAddress, \ - protocolAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ - ZCL_MATCH_PROTOCOL_ADDRESS_RESPONSE_COMMAND_ID, \ - "8s", \ - deviceIeeeAddress, \ - protocolAddress); +#define emberAfFillCommandGenericTunnelClusterMatchProtocolAddressResponse(deviceIeeeAddress, protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_MATCH_PROTOCOL_ADDRESS_RESPONSE_COMMAND_ID, "8s", deviceIeeeAddress, protocolAddress); - -/** @brief This command is typically sent upon startup, and whenever the ProtocolAddress attribute changes. It is typically multicast to a group of inter-communicating Generic Tunnel clusters. +/** @brief This command is typically sent upon startup, and whenever the ProtocolAddress attribute changes. It is typically + * multicast to a group of inter-communicating Generic Tunnel clusters. * * Cluster: Generic Tunnel, The minimum common commands and attributes required to tunnel any protocol. * Command: AdvertiseProtocolAddress * @param protocolAddress uint8_t* */ -#define emberAfFillCommandGenericTunnelClusterAdvertiseProtocolAddress(protocolAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ - ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, \ - "s", \ - protocolAddress); - +#define emberAfFillCommandGenericTunnelClusterAdvertiseProtocolAddress(protocolAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GENERIC_TUNNEL_CLUSTER_ID, \ + ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID, "s", protocolAddress); /** @} END Generic Tunnel Commands */ - /** @name BACnet Protocol Tunnel Commands */ // @{ -/** @brief This command is generated when a BACnet network layer wishes to transfer a BACnet NPDU across a ZigBee tunnel to another BACnet network layer. +/** @brief This command is generated when a BACnet network layer wishes to transfer a BACnet NPDU across a ZigBee tunnel to another + * BACnet network layer. * * Cluster: BACnet Protocol Tunnel, Commands and attributes required to tunnel the BACnet protocol. * Command: TransferNpdu * @param npdu uint8_t* * @param npduLen uint16_t */ -#define emberAfFillCommandBacnetProtocolTunnelClusterTransferNpdu(npdu, \ - npduLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_TRANSFER_NPDU_COMMAND_ID, \ - "b", \ - npdu, \ - npduLen); - +#define emberAfFillCommandBacnetProtocolTunnelClusterTransferNpdu(npdu, npduLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_TRANSFER_NPDU_COMMAND_ID, "b", npdu, npduLen); /** @} END BACnet Protocol Tunnel Commands */ - /** @name 11073 Protocol Tunnel Commands */ // @{ -/** @brief This command is generated when an 11073 network layer wishes to transfer an 11073 APDU across a ZigBee tunnel to another 11073 network layer. +/** @brief This command is generated when an 11073 network layer wishes to transfer an 11073 APDU across a ZigBee tunnel to another + * 11073 network layer. * * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. * Command: TransferAPDU * @param apdu uint8_t* */ -#define emberAfFillCommand11073ProtocolTunnelClusterTransferAPDU(apdu) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_TRANSFER_A_P_D_U_COMMAND_ID, \ - "s", \ - apdu); - +#define emberAfFillCommand11073ProtocolTunnelClusterTransferAPDU(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_TRANSFER_A_P_D_U_COMMAND_ID, "s", apdu); -/** @brief This command is generated when an Health Care client wishes to connect to a Health Care server for the purposes of transmitting 11073 APDUs across the 11073 tunnel. +/** @brief This command is generated when an Health Care client wishes to connect to a Health Care server for the purposes of + * transmitting 11073 APDUs across the 11073 tunnel. * * Cluster: 11073 Protocol Tunnel, Attributes and commands for the 11073 protocol tunnel used for ZigBee Health Care. * Command: ConnectRequest @@ -7052,20 +4439,10 @@ * @param managerTarget uint8_t* * @param managerEndpoint uint8_t */ -#define emberAfFillCommand11073ProtocolTunnelClusterConnectRequest(connectControl, \ - idleTimeout, \ - managerTarget, \ - managerEndpoint) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_CONNECT_REQUEST_COMMAND_ID, \ - "uv8u", \ - connectControl, \ - idleTimeout, \ - managerTarget, \ - managerEndpoint); - +#define emberAfFillCommand11073ProtocolTunnelClusterConnectRequest(connectControl, idleTimeout, managerTarget, managerEndpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_CONNECT_REQUEST_COMMAND_ID, "uv8u", connectControl, \ + idleTimeout, managerTarget, managerEndpoint); /** @brief This command is generated when an Health Care client wishes to disconnect from a Health Care server. * @@ -7073,14 +4450,9 @@ * Command: DisconnectRequest * @param managerIEEEAddress uint8_t* */ -#define emberAfFillCommand11073ProtocolTunnelClusterDisconnectRequest(managerIEEEAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_DISCONNECT_REQUEST_COMMAND_ID, \ - "8", \ - managerIEEEAddress); - +#define emberAfFillCommand11073ProtocolTunnelClusterDisconnectRequest(managerIEEEAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_DISCONNECT_REQUEST_COMMAND_ID, "8", managerIEEEAddress); /** @brief Generated in response to requests related to connection or any event that causes the tunnel to become disconnected. * @@ -7088,18 +4460,13 @@ * Command: ConnectStatusNotification * @param connectStatus uint8_t */ -#define emberAfFillCommand11073ProtocolTunnelClusterConnectStatusNotification(connectStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, \ - "u", \ - connectStatus); - +#define emberAfFillCommand11073ProtocolTunnelClusterConnectStatusNotification(connectStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID, "u", \ + connectStatus); /** @} END 11073 Protocol Tunnel Commands */ - /** @name ISO 7816 Protocol Tunnel Commands */ // @{ /** @brief Command description for TransferApdu @@ -7108,14 +4475,9 @@ * Command: TransferApdu * @param apdu uint8_t* */ -#define emberAfFillCommandIso7816ProtocolTunnelClusterServerToClientTransferApdu(apdu) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_TRANSFER_APDU_COMMAND_ID, \ - "s", \ - apdu); - +#define emberAfFillCommandIso7816ProtocolTunnelClusterServerToClientTransferApdu(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_TRANSFER_APDU_COMMAND_ID, "s", apdu); /** @brief Command description for TransferApdu * @@ -7123,50 +4485,38 @@ * Command: TransferApdu * @param apdu uint8_t* */ -#define emberAfFillCommandIso7816ProtocolTunnelClusterClientToServerTransferApdu(apdu) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_TRANSFER_APDU_COMMAND_ID, \ - "s", \ - apdu); - +#define emberAfFillCommandIso7816ProtocolTunnelClusterClientToServerTransferApdu(apdu) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_TRANSFER_APDU_COMMAND_ID, "s", apdu); /** @brief Command description for InsertSmartCard * * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. * Command: InsertSmartCard */ -#define emberAfFillCommandIso7816ProtocolTunnelClusterInsertSmartCard() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_INSERT_SMART_CARD_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIso7816ProtocolTunnelClusterInsertSmartCard() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_INSERT_SMART_CARD_COMMAND_ID, ""); /** @brief Command description for ExtractSmartCard * * Cluster: ISO 7816 Protocol Tunnel, Commands and attributes for mobile office solutions including ZigBee devices. * Command: ExtractSmartCard */ -#define emberAfFillCommandIso7816ProtocolTunnelClusterExtractSmartCard() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, \ - ZCL_EXTRACT_SMART_CARD_COMMAND_ID, \ - ""); - +#define emberAfFillCommandIso7816ProtocolTunnelClusterExtractSmartCard() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, ZCL_EXTRACT_SMART_CARD_COMMAND_ID, ""); /** @} END ISO 7816 Protocol Tunnel Commands */ - /** @name Price Commands */ // @{ -/** @brief The PublishPrice command is generated in response to receiving a Get Current Price command, in response to a Get Scheduled Prices command, and when an update to the pricing information is available from the commodity provider, either before or when a TOU price becomes active. +/** @brief The PublishPrice command is generated in response to receiving a Get Current Price command, in response to a Get + * Scheduled Prices command, and when an update to the pricing information is available from the commodity provider, either before + * or when a TOU price becomes active. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishPrice + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishPrice * @param providerId uint32_t * @param rateLabel uint8_t* * @param issuerEventId uint32_t @@ -7192,65 +4542,24 @@ * @param extendedPriceTier uint8_t * @param extendedRegisterTier uint8_t */ -#define emberAfFillCommandPriceClusterPublishPrice(providerId, \ - rateLabel, \ - issuerEventId, \ - currentTime, \ - unitOfMeasure, \ - currency, \ - priceTrailingDigitAndPriceTier, \ - numberOfPriceTiersAndRegisterTier, \ - startTime, \ - durationInMinutes, \ - price, \ - priceRatio, \ - generationPrice, \ - generationPriceRatio, \ - alternateCostDelivered, \ - alternateCostUnit, \ - alternateCostTrailingDigit, \ - numberOfBlockThresholds, \ - priceControl, \ - numberOfGenerationTiers, \ - generationTier, \ - extendedNumberOfPriceTiers, \ - extendedPriceTier, \ - extendedRegisterTier) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_PRICE_COMMAND_ID, \ - "wswwuvuuwvwuwuwuuuuuuuuu", \ - providerId, \ - rateLabel, \ - issuerEventId, \ - currentTime, \ - unitOfMeasure, \ - currency, \ - priceTrailingDigitAndPriceTier, \ - numberOfPriceTiersAndRegisterTier, \ - startTime, \ - durationInMinutes, \ - price, \ - priceRatio, \ - generationPrice, \ - generationPriceRatio, \ - alternateCostDelivered, \ - alternateCostUnit, \ - alternateCostTrailingDigit, \ - numberOfBlockThresholds, \ - priceControl, \ - numberOfGenerationTiers, \ - generationTier, \ - extendedNumberOfPriceTiers, \ - extendedPriceTier, \ - extendedRegisterTier); - - -/** @brief The PublishBlockPeriod command is generated in response to receiving a GetBlockPeriod(s) command or when an update to the block tariff schedule is available from the commodity provider. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishBlockPeriod +#define emberAfFillCommandPriceClusterPublishPrice( \ + providerId, rateLabel, issuerEventId, currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier, \ + numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, generationPriceRatio, \ + alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit, numberOfBlockThresholds, priceControl, \ + numberOfGenerationTiers, generationTier, extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_PRICE_COMMAND_ID, "wswwuvuuwvwuwuwuuuuuuuuu", providerId, rateLabel, issuerEventId, \ + currentTime, unitOfMeasure, currency, priceTrailingDigitAndPriceTier, \ + numberOfPriceTiersAndRegisterTier, startTime, durationInMinutes, price, priceRatio, generationPrice, \ + generationPriceRatio, alternateCostDelivered, alternateCostUnit, alternateCostTrailingDigit, \ + numberOfBlockThresholds, priceControl, numberOfGenerationTiers, generationTier, \ + extendedNumberOfPriceTiers, extendedPriceTier, extendedRegisterTier); + +/** @brief The PublishBlockPeriod command is generated in response to receiving a GetBlockPeriod(s) command or when an update to the + * block tariff schedule is available from the commodity provider. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishBlockPeriod * @param providerId uint32_t * @param issuerEventId uint32_t * @param blockPeriodStartTime uint32_t @@ -7260,84 +4569,52 @@ * @param tariffType uint8_t * @param tariffResolutionPeriod uint8_t */ -#define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, \ - issuerEventId, \ - blockPeriodStartTime, \ - blockPeriodDuration, \ - blockPeriodControl, \ - blockPeriodDurationType, \ - tariffType, \ - tariffResolutionPeriod) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, \ - "wwwxuuuu", \ - providerId, \ - issuerEventId, \ - blockPeriodStartTime, \ - blockPeriodDuration, \ - blockPeriodControl, \ - blockPeriodDurationType, \ - tariffType, \ - tariffResolutionPeriod); - - -/** @brief The PublishConversionFactor command is sent in response to a GetConversionFactor command or if a new Conversion factor is available. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishConversionFactor +#define emberAfFillCommandPriceClusterPublishBlockPeriod(providerId, issuerEventId, blockPeriodStartTime, blockPeriodDuration, \ + blockPeriodControl, blockPeriodDurationType, tariffType, \ + tariffResolutionPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID, "wwwxuuuu", providerId, issuerEventId, blockPeriodStartTime, \ + blockPeriodDuration, blockPeriodControl, blockPeriodDurationType, tariffType, \ + tariffResolutionPeriod); + +/** @brief The PublishConversionFactor command is sent in response to a GetConversionFactor command or if a new Conversion factor is + * available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishConversionFactor * @param issuerEventId uint32_t * @param startTime uint32_t * @param conversionFactor uint32_t * @param conversionFactorTrailingDigit uint8_t */ -#define emberAfFillCommandPriceClusterPublishConversionFactor(issuerEventId, \ - startTime, \ - conversionFactor, \ - conversionFactorTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, \ - "wwwu", \ - issuerEventId, \ - startTime, \ - conversionFactor, \ - conversionFactorTrailingDigit); - - -/** @brief The PublishCalorificValue command is sent in response to a GetCalorificValue command or if a new calorific value is available. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishCalorificValue +#define emberAfFillCommandPriceClusterPublishConversionFactor(issuerEventId, startTime, conversionFactor, \ + conversionFactorTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID, "wwwu", issuerEventId, startTime, conversionFactor, \ + conversionFactorTrailingDigit); + +/** @brief The PublishCalorificValue command is sent in response to a GetCalorificValue command or if a new calorific value is + * available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishCalorificValue * @param issuerEventId uint32_t * @param startTime uint32_t * @param calorificValue uint32_t * @param calorificValueUnit uint8_t * @param calorificValueTrailingDigit uint8_t */ -#define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, \ - startTime, \ - calorificValue, \ - calorificValueUnit, \ - calorificValueTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, \ - "wwwuu", \ - issuerEventId, \ - startTime, \ - calorificValue, \ - calorificValueUnit, \ - calorificValueTrailingDigit); - - -/** @brief The PublishTariffInformation command is sent in response to a GetTariffInformation command or if new tariff information is available (including price matrix and block thresholds). - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishTariffInformation +#define emberAfFillCommandPriceClusterPublishCalorificValue(issuerEventId, startTime, calorificValue, calorificValueUnit, \ + calorificValueTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID, "wwwuu", issuerEventId, startTime, calorificValue, \ + calorificValueUnit, calorificValueTrailingDigit); + +/** @brief The PublishTariffInformation command is sent in response to a GetTariffInformation command or if new tariff information + * is available (including price matrix and block thresholds). + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishTariffInformation * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerTariffId uint32_t @@ -7354,47 +4631,21 @@ * @param blockThresholdMultiplier uint32_t * @param blockThresholdDivisor uint32_t */ -#define emberAfFillCommandPriceClusterPublishTariffInformation(providerId, \ - issuerEventId, \ - issuerTariffId, \ - startTime, \ - tariffTypeChargingScheme, \ - tariffLabel, \ - numberOfPriceTiersInUse, \ - numberOfBlockThresholdsInUse, \ - unitOfMeasure, \ - currency, \ - priceTrailingDigit, \ - standingCharge, \ - tierBlockMode, \ - blockThresholdMultiplier, \ - blockThresholdDivisor) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, \ - "wwwwusuuuvuwuxx", \ - providerId, \ - issuerEventId, \ - issuerTariffId, \ - startTime, \ - tariffTypeChargingScheme, \ - tariffLabel, \ - numberOfPriceTiersInUse, \ - numberOfBlockThresholdsInUse, \ - unitOfMeasure, \ - currency, \ - priceTrailingDigit, \ - standingCharge, \ - tierBlockMode, \ - blockThresholdMultiplier, \ - blockThresholdDivisor); - - -/** @brief PublishPriceMatrix command is used to publish the Block Price Information Set (up to 15 tiers x 15 blocks) and the Extended Price Information Set (up to 48 tiers). The PublishPriceMatrix command is sent in response to a GetPriceMatrix command. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishPriceMatrix +#define emberAfFillCommandPriceClusterPublishTariffInformation( \ + providerId, issuerEventId, issuerTariffId, startTime, tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, \ + numberOfBlockThresholdsInUse, unitOfMeasure, currency, priceTrailingDigit, standingCharge, tierBlockMode, \ + blockThresholdMultiplier, blockThresholdDivisor) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID, "wwwwusuuuvuwuxx", providerId, issuerEventId, \ + issuerTariffId, startTime, tariffTypeChargingScheme, tariffLabel, numberOfPriceTiersInUse, \ + numberOfBlockThresholdsInUse, unitOfMeasure, currency, priceTrailingDigit, standingCharge, \ + tierBlockMode, blockThresholdMultiplier, blockThresholdDivisor); + +/** @brief PublishPriceMatrix command is used to publish the Block Price Information Set (up to 15 tiers x 15 blocks) and the + * Extended Price Information Set (up to 48 tiers). The PublishPriceMatrix command is sent in response to a GetPriceMatrix command. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishPriceMatrix * @param providerId uint32_t * @param issuerEventId uint32_t * @param startTime uint32_t @@ -7405,35 +4656,16 @@ * @param payload uint8_t* * @param payloadLen uint16_t */ -#define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, \ - issuerEventId, \ - startTime, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - subPayloadControl, \ - payload, \ - payloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, \ - "wwwwuuub", \ - providerId, \ - issuerEventId, \ - startTime, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - subPayloadControl, \ - payload, \ - payloadLen); - +#define emberAfFillCommandPriceClusterPublishPriceMatrix(providerId, issuerEventId, startTime, issuerTariffId, commandIndex, \ + numberOfCommands, subPayloadControl, payload, payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID, "wwwwuuub", providerId, issuerEventId, startTime, \ + issuerTariffId, commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen); /** @brief The PublishBlockThreshold command is sent in response to a GetBlockThreshold command. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishBlockThresholds + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishBlockThresholds * @param providerId uint32_t * @param issuerEventId uint32_t * @param startTime uint32_t @@ -7444,35 +4676,16 @@ * @param payload uint8_t* * @param payloadLen uint16_t */ -#define emberAfFillCommandPriceClusterPublishBlockThresholds(providerId, \ - issuerEventId, \ - startTime, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - subPayloadControl, \ - payload, \ - payloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, \ - "wwwwuuub", \ - providerId, \ - issuerEventId, \ - startTime, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - subPayloadControl, \ - payload, \ - payloadLen); - +#define emberAfFillCommandPriceClusterPublishBlockThresholds(providerId, issuerEventId, startTime, issuerTariffId, commandIndex, \ + numberOfCommands, subPayloadControl, payload, payloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID, "wwwwuuub", providerId, issuerEventId, startTime, \ + issuerTariffId, commandIndex, numberOfCommands, subPayloadControl, payload, payloadLen); /** @brief The PublishCO2Value command is sent in response to a GetCO2Value command or if a new CO2 conversion factor is available. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishCO2Value + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishCO2Value * @param providerId uint32_t * @param issuerEventId uint32_t * @param startTime uint32_t @@ -7481,31 +4694,17 @@ * @param cO2ValueUnit uint8_t * @param cO2ValueTrailingDigit uint8_t */ -#define emberAfFillCommandPriceClusterPublishCO2Value(providerId, \ - issuerEventId, \ - startTime, \ - tariffType, \ - cO2Value, \ - cO2ValueUnit, \ - cO2ValueTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID, \ - "wwwuwuu", \ - providerId, \ - issuerEventId, \ - startTime, \ - tariffType, \ - cO2Value, \ - cO2ValueUnit, \ - cO2ValueTrailingDigit); - - -/** @brief The PublishTierLabels command is generated in response to receiving a GetTierLabels command or when there is a tier label change. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishTierLabels +#define emberAfFillCommandPriceClusterPublishCO2Value(providerId, issuerEventId, startTime, tariffType, cO2Value, cO2ValueUnit, \ + cO2ValueTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID, "wwwuwuu", providerId, issuerEventId, startTime, tariffType, \ + cO2Value, cO2ValueUnit, cO2ValueTrailingDigit); + +/** @brief The PublishTierLabels command is generated in response to receiving a GetTierLabels command or when there is a tier label + * change. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishTierLabels * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerTariffId uint32_t @@ -7515,33 +4714,17 @@ * @param tierLabelsPayload uint8_t* * @param tierLabelsPayloadLen uint16_t */ -#define emberAfFillCommandPriceClusterPublishTierLabels(providerId, \ - issuerEventId, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - numberOfLabels, \ - tierLabelsPayload, \ - tierLabelsPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, \ - "wwwuuub", \ - providerId, \ - issuerEventId, \ - issuerTariffId, \ - commandIndex, \ - numberOfCommands, \ - numberOfLabels, \ - tierLabelsPayload, \ - tierLabelsPayloadLen); - - -/** @brief The PublishBillingPeriod command is generated in response to receiving a GetBillingPeriod(s) command or when an update to the Billing schedule is available from the commodity Supplier. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishBillingPeriod +#define emberAfFillCommandPriceClusterPublishTierLabels(providerId, issuerEventId, issuerTariffId, commandIndex, numberOfCommands, \ + numberOfLabels, tierLabelsPayload, tierLabelsPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_TIER_LABELS_COMMAND_ID, "wwwuuub", providerId, issuerEventId, issuerTariffId, \ + commandIndex, numberOfCommands, numberOfLabels, tierLabelsPayload, tierLabelsPayloadLen); + +/** @brief The PublishBillingPeriod command is generated in response to receiving a GetBillingPeriod(s) command or when an update to + * the Billing schedule is available from the commodity Supplier. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishBillingPeriod * @param providerId uint32_t * @param issuerEventId uint32_t * @param billingPeriodStartTime uint32_t @@ -7549,29 +4732,18 @@ * @param billingPeriodDurationType uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, \ - issuerEventId, \ - billingPeriodStartTime, \ - billingPeriodDuration, \ - billingPeriodDurationType, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, \ - "wwwxuu", \ - providerId, \ - issuerEventId, \ - billingPeriodStartTime, \ - billingPeriodDuration, \ - billingPeriodDurationType, \ - tariffType); - - -/** @brief The PublishConsolidatedBill command is used to make consolidated billing information of previous billing periods available to other end devices. This command is issued in response to a GetConsolidatedBill command or if new billing information is available. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishConsolidatedBill +#define emberAfFillCommandPriceClusterPublishBillingPeriod(providerId, issuerEventId, billingPeriodStartTime, \ + billingPeriodDuration, billingPeriodDurationType, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID, "wwwxuu", providerId, issuerEventId, billingPeriodStartTime, \ + billingPeriodDuration, billingPeriodDurationType, tariffType); + +/** @brief The PublishConsolidatedBill command is used to make consolidated billing information of previous billing periods + * available to other end devices. This command is issued in response to a GetConsolidatedBill command or if new billing + * information is available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishConsolidatedBill * @param providerId uint32_t * @param issuerEventId uint32_t * @param billingPeriodStartTime uint32_t @@ -7582,35 +4754,18 @@ * @param currency uint16_t * @param billTrailingDigit uint8_t */ -#define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, \ - issuerEventId, \ - billingPeriodStartTime, \ - billingPeriodDuration, \ - billingPeriodDurationType, \ - tariffType, \ - consolidatedBill, \ - currency, \ - billTrailingDigit) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, \ - "wwwxuuwvu", \ - providerId, \ - issuerEventId, \ - billingPeriodStartTime, \ - billingPeriodDuration, \ - billingPeriodDurationType, \ - tariffType, \ - consolidatedBill, \ - currency, \ - billTrailingDigit); - +#define emberAfFillCommandPriceClusterPublishConsolidatedBill(providerId, issuerEventId, billingPeriodStartTime, \ + billingPeriodDuration, billingPeriodDurationType, tariffType, \ + consolidatedBill, currency, billTrailingDigit) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID, "wwwxuuwvu", providerId, issuerEventId, \ + billingPeriodStartTime, billingPeriodDuration, billingPeriodDurationType, tariffType, \ + consolidatedBill, currency, billTrailingDigit); /** @brief The PublishCPPEvent command is sent from an ESI to its price clients to notify them of a Critical Peak Pricing event. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishCppEvent + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishCppEvent * @param providerId uint32_t * @param issuerEventId uint32_t * @param startTime uint32_t @@ -7619,31 +4774,16 @@ * @param cppPriceTier uint8_t * @param cppAuth uint8_t */ -#define emberAfFillCommandPriceClusterPublishCppEvent(providerId, \ - issuerEventId, \ - startTime, \ - durationInMinutes, \ - tariffType, \ - cppPriceTier, \ - cppAuth) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, \ - "wwwvuuu", \ - providerId, \ - issuerEventId, \ - startTime, \ - durationInMinutes, \ - tariffType, \ - cppPriceTier, \ - cppAuth); - +#define emberAfFillCommandPriceClusterPublishCppEvent(providerId, issuerEventId, startTime, durationInMinutes, tariffType, \ + cppPriceTier, cppAuth) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CPP_EVENT_COMMAND_ID, "wwwvuuu", providerId, issuerEventId, startTime, \ + durationInMinutes, tariffType, cppPriceTier, cppAuth); /** @brief The PublishCreditPayment command is used to update the credit payment information is available. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishCreditPayment + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishCreditPayment * @param providerId uint32_t * @param issuerEventId uint32_t * @param creditPaymentDueDate uint32_t @@ -7653,33 +4793,19 @@ * @param creditPaymentDate uint32_t * @param creditPaymentRef uint8_t* */ -#define emberAfFillCommandPriceClusterPublishCreditPayment(providerId, \ - issuerEventId, \ - creditPaymentDueDate, \ - creditPaymentOverDueAmount, \ - creditPaymentStatus, \ - creditPayment, \ - creditPaymentDate, \ - creditPaymentRef) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, \ - "wwwwuwws", \ - providerId, \ - issuerEventId, \ - creditPaymentDueDate, \ - creditPaymentOverDueAmount, \ - creditPaymentStatus, \ - creditPayment, \ - creditPaymentDate, \ - creditPaymentRef); - - -/** @brief The PublishCurrencyConversion command is sent in response to a GetCurrencyConversion command or when a new currency becomes available. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PublishCurrencyConversion +#define emberAfFillCommandPriceClusterPublishCreditPayment(providerId, issuerEventId, creditPaymentDueDate, \ + creditPaymentOverDueAmount, creditPaymentStatus, creditPayment, \ + creditPaymentDate, creditPaymentRef) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID, "wwwwuwws", providerId, issuerEventId, creditPaymentDueDate, \ + creditPaymentOverDueAmount, creditPaymentStatus, creditPayment, creditPaymentDate, \ + creditPaymentRef); + +/** @brief The PublishCurrencyConversion command is sent in response to a GetCurrencyConversion command or when a new currency + * becomes available. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PublishCurrencyConversion * @param providerId uint32_t * @param issuerEventId uint32_t * @param startTime uint32_t @@ -7689,382 +4815,236 @@ * @param conversionFactorTrailingDigit uint8_t * @param currencyChangeControlFlags uint32_t */ -#define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, \ - issuerEventId, \ - startTime, \ - oldCurrency, \ - newCurrency, \ - conversionFactor, \ - conversionFactorTrailingDigit, \ - currencyChangeControlFlags) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, \ - "wwwvvwuw", \ - providerId, \ - issuerEventId, \ - startTime, \ - oldCurrency, \ - newCurrency, \ - conversionFactor, \ - conversionFactorTrailingDigit, \ - currencyChangeControlFlags); - +#define emberAfFillCommandPriceClusterPublishCurrencyConversion(providerId, issuerEventId, startTime, oldCurrency, newCurrency, \ + conversionFactor, conversionFactorTrailingDigit, \ + currencyChangeControlFlags) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID, "wwwvvwuw", providerId, issuerEventId, startTime, \ + oldCurrency, newCurrency, conversionFactor, conversionFactorTrailingDigit, \ + currencyChangeControlFlags); /** @brief The CancelTariff command indicates that all data associated with a particular tariff instance should be discarded. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: CancelTariff + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: CancelTariff * @param providerId uint32_t * @param issuerTariffId uint32_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterCancelTariff(providerId, \ - issuerTariffId, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_CANCEL_TARIFF_COMMAND_ID, \ - "wwu", \ - providerId, \ - issuerTariffId, \ - tariffType); - +#define emberAfFillCommandPriceClusterCancelTariff(providerId, issuerTariffId, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PRICE_CLUSTER_ID, \ + ZCL_CANCEL_TARIFF_COMMAND_ID, "wwu", providerId, issuerTariffId, tariffType); /** @brief The GetCurrentPrice command initiates a PublishPrice command for the current time. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetCurrentPrice + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetCurrentPrice * @param commandOptions uint8_t */ -#define emberAfFillCommandPriceClusterGetCurrentPrice(commandOptions) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CURRENT_PRICE_COMMAND_ID, \ - "u", \ - commandOptions); - +#define emberAfFillCommandPriceClusterGetCurrentPrice(commandOptions) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CURRENT_PRICE_COMMAND_ID, "u", commandOptions); /** @brief The GetScheduledPrices command initiates a PublishPrice command for available price events. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetScheduledPrices + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetScheduledPrices * @param startTime uint32_t * @param numberOfEvents uint8_t */ -#define emberAfFillCommandPriceClusterGetScheduledPrices(startTime, \ - numberOfEvents) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_SCHEDULED_PRICES_COMMAND_ID, \ - "wu", \ - startTime, \ - numberOfEvents); - +#define emberAfFillCommandPriceClusterGetScheduledPrices(startTime, numberOfEvents) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_SCHEDULED_PRICES_COMMAND_ID, "wu", startTime, numberOfEvents); /** @brief The PriceAcknowledgement command described provides the ability to acknowledge a previously sent PublishPrice command. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: PriceAcknowledgement + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: PriceAcknowledgement * @param providerId uint32_t * @param issuerEventId uint32_t * @param priceAckTime uint32_t * @param control uint8_t */ -#define emberAfFillCommandPriceClusterPriceAcknowledgement(providerId, \ - issuerEventId, \ - priceAckTime, \ - control) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID, \ - "wwwu", \ - providerId, \ - issuerEventId, \ - priceAckTime, \ - control); - +#define emberAfFillCommandPriceClusterPriceAcknowledgement(providerId, issuerEventId, priceAckTime, control) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID, "wwwu", providerId, issuerEventId, priceAckTime, control); /** @brief The GetBlockPeriods command initiates a PublishBlockPeriod command for the currently scheduled block periods. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetBlockPeriods + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetBlockPeriods * @param startTime uint32_t * @param numberOfEvents uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterGetBlockPeriods(startTime, \ - numberOfEvents, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_BLOCK_PERIODS_COMMAND_ID, \ - "wuu", \ - startTime, \ - numberOfEvents, \ - tariffType); - +#define emberAfFillCommandPriceClusterGetBlockPeriods(startTime, numberOfEvents, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BLOCK_PERIODS_COMMAND_ID, "wuu", startTime, numberOfEvents, tariffType); /** @brief The GetConversionFactor command initiates a PublishConversionFactor command for the scheduled conversion factor updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetConversionFactor + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetConversionFactor * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t */ -#define emberAfFillCommandPriceClusterGetConversionFactor(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CONVERSION_FACTOR_COMMAND_ID, \ - "wwu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands); - +#define emberAfFillCommandPriceClusterGetConversionFactor(earliestStartTime, minIssuerEventId, numberOfCommands) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CONVERSION_FACTOR_COMMAND_ID, "wwu", earliestStartTime, minIssuerEventId, numberOfCommands); /** @brief The GetCalorificValue command initiates a PublishCalorificValue command for the scheduled conversion factor updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetCalorificValue + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetCalorificValue * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t */ -#define emberAfFillCommandPriceClusterGetCalorificValue(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CALORIFIC_VALUE_COMMAND_ID, \ - "wwu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands); - +#define emberAfFillCommandPriceClusterGetCalorificValue(earliestStartTime, minIssuerEventId, numberOfCommands) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CALORIFIC_VALUE_COMMAND_ID, "wwu", earliestStartTime, minIssuerEventId, numberOfCommands); /** @brief The GetTariffInformation command initiates a PublishTariffInformation command for the scheduled tariff updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetTariffInformation + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetTariffInformation * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterGetTariffInformation(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_TARIFF_INFORMATION_COMMAND_ID, \ - "wwuu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType); - +#define emberAfFillCommandPriceClusterGetTariffInformation(earliestStartTime, minIssuerEventId, numberOfCommands, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TARIFF_INFORMATION_COMMAND_ID, "wwuu", earliestStartTime, minIssuerEventId, \ + numberOfCommands, tariffType); /** @brief The GetPriceMatrix command initiates a PublishPriceMatrix command for the scheduled Price Matrix updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetPriceMatrix + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetPriceMatrix * @param issuerTariffId uint32_t */ -#define emberAfFillCommandPriceClusterGetPriceMatrix(issuerTariffId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_PRICE_MATRIX_COMMAND_ID, \ - "w", \ - issuerTariffId); - +#define emberAfFillCommandPriceClusterGetPriceMatrix(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_PRICE_MATRIX_COMMAND_ID, "w", issuerTariffId); /** @brief The GetBlockThresholds command initiates a PublishBlockThreshold command for the scheduled Block Threshold updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetBlockThresholds + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetBlockThresholds * @param issuerTariffId uint32_t */ -#define emberAfFillCommandPriceClusterGetBlockThresholds(issuerTariffId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID, \ - "w", \ - issuerTariffId); - +#define emberAfFillCommandPriceClusterGetBlockThresholds(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID, "w", issuerTariffId); /** @brief The GetCO2Value command initiates a PublishCO2Value command for the scheduled CO2 conversion factor updates. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetCO2Value + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetCO2Value * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterGetCO2Value(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_C_O2_VALUE_COMMAND_ID, \ - "wwuu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType); - - -/** @brief The GetTierLabels command allows a client to retrieve the tier labels associated with a given tariff; this command initiates a PublishTierLabels command from the server. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetTierLabels +#define emberAfFillCommandPriceClusterGetCO2Value(earliestStartTime, minIssuerEventId, numberOfCommands, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_C_O2_VALUE_COMMAND_ID, "wwuu", earliestStartTime, minIssuerEventId, numberOfCommands, \ + tariffType); + +/** @brief The GetTierLabels command allows a client to retrieve the tier labels associated with a given tariff; this command + * initiates a PublishTierLabels command from the server. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetTierLabels * @param issuerTariffId uint32_t */ -#define emberAfFillCommandPriceClusterGetTierLabels(issuerTariffId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_TIER_LABELS_COMMAND_ID, \ - "w", \ - issuerTariffId); +#define emberAfFillCommandPriceClusterGetTierLabels(issuerTariffId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TIER_LABELS_COMMAND_ID, "w", issuerTariffId); - -/** @brief The GetBillingPeriod command initiates one or more PublishBillingPeriod commands for the currently scheduled billing periods. +/** @brief The GetBillingPeriod command initiates one or more PublishBillingPeriod commands for the currently scheduled billing + * periods. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetBillingPeriod + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetBillingPeriod * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterGetBillingPeriod(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_BILLING_PERIOD_COMMAND_ID, \ - "wwuu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType); - - -/** @brief The GetConsolidatedBill command initiates one or more PublishConsolidatedBill commands with the requested billing information. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetConsolidatedBill +#define emberAfFillCommandPriceClusterGetBillingPeriod(earliestStartTime, minIssuerEventId, numberOfCommands, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_BILLING_PERIOD_COMMAND_ID, "wwuu", earliestStartTime, minIssuerEventId, numberOfCommands, \ + tariffType); + +/** @brief The GetConsolidatedBill command initiates one or more PublishConsolidatedBill commands with the requested billing + * information. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetConsolidatedBill * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCommands uint8_t * @param tariffType uint8_t */ -#define emberAfFillCommandPriceClusterGetConsolidatedBill(earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID, \ - "wwuu", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCommands, \ - tariffType); - - -/** @brief The CPPEventResponse command is sent from a Client (IHD) to the ESI to notify it of a Critical Peak Pricing event authorization. - * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: CppEventResponse +#define emberAfFillCommandPriceClusterGetConsolidatedBill(earliestStartTime, minIssuerEventId, numberOfCommands, tariffType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID, "wwuu", earliestStartTime, minIssuerEventId, numberOfCommands, \ + tariffType); + +/** @brief The CPPEventResponse command is sent from a Client (IHD) to the ESI to notify it of a Critical Peak Pricing event + * authorization. + * + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: CppEventResponse * @param issuerEventId uint32_t * @param cppAuth uint8_t */ -#define emberAfFillCommandPriceClusterCppEventResponse(issuerEventId, \ - cppAuth) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_CPP_EVENT_RESPONSE_COMMAND_ID, \ - "wu", \ - issuerEventId, \ - cppAuth); - +#define emberAfFillCommandPriceClusterCppEventResponse(issuerEventId, cppAuth) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_CPP_EVENT_RESPONSE_COMMAND_ID, "wu", issuerEventId, cppAuth); /** @brief The GetCreditPayment command initiates PublishCreditPayment commands for the requested credit payment information. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetCreditPayment + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetCreditPayment * @param latestEndTime uint32_t * @param numberOfRecords uint8_t */ -#define emberAfFillCommandPriceClusterGetCreditPayment(latestEndTime, \ - numberOfRecords) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CREDIT_PAYMENT_COMMAND_ID, \ - "wu", \ - latestEndTime, \ - numberOfRecords); +#define emberAfFillCommandPriceClusterGetCreditPayment(latestEndTime, numberOfRecords) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CREDIT_PAYMENT_COMMAND_ID, "wu", latestEndTime, numberOfRecords); - -/** @brief The GetCurrencyConversionCommand command initiates a PublishCurrencyConversion command for the currency conversion factor updates. A server shall be capable of storing both the old and the new currencies. +/** @brief The GetCurrencyConversionCommand command initiates a PublishCurrencyConversion command for the currency conversion factor + * updates. A server shall be capable of storing both the old and the new currencies. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetCurrencyConversionCommand + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetCurrencyConversionCommand */ -#define emberAfFillCommandPriceClusterGetCurrencyConversionCommand() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPriceClusterGetCurrencyConversionCommand() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID, ""); /** @brief The GetTariffCancellation command initiates the return of the last CancelTariff command held on the associated server. * - * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the premises. - * Command: GetTariffCancellation + * Cluster: Price, The Price Cluster provides the mechanism for communicating Gas, Energy, or Water pricing information within the + * premises. Command: GetTariffCancellation */ -#define emberAfFillCommandPriceClusterGetTariffCancellation() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PRICE_CLUSTER_ID, \ - ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandPriceClusterGetTariffCancellation() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PRICE_CLUSTER_ID, \ + ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID, ""); /** @} END Price Commands */ - /** @name Demand Response and Load Control Commands */ // @{ /** @brief Command description for LoadControlEvent * - * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. - * Command: LoadControlEvent + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand + * Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. Command: + * LoadControlEvent * @param issuerEventId uint32_t * @param deviceClass uint16_t * @param utilityEnrollmentGroup uint8_t @@ -8079,85 +5059,50 @@ * @param dutyCycle uint8_t * @param eventControl uint8_t */ -#define emberAfFillCommandDemandResponseLoadControlClusterLoadControlEvent(issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - startTime, \ - durationInMinutes, \ - criticalityLevel, \ - coolingTemperatureOffset, \ - heatingTemperatureOffset, \ - coolingTemperatureSetPoint, \ - heatingTemperatureSetPoint, \ - averageLoadAdjustmentPercentage, \ - dutyCycle, \ - eventControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ - ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, \ - "wvuwvuuuvvuuu", \ - issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - startTime, \ - durationInMinutes, \ - criticalityLevel, \ - coolingTemperatureOffset, \ - heatingTemperatureOffset, \ - coolingTemperatureSetPoint, \ - heatingTemperatureSetPoint, \ - averageLoadAdjustmentPercentage, \ - dutyCycle, \ - eventControl); - +#define emberAfFillCommandDemandResponseLoadControlClusterLoadControlEvent( \ + issuerEventId, deviceClass, utilityEnrollmentGroup, startTime, durationInMinutes, criticalityLevel, coolingTemperatureOffset, \ + heatingTemperatureOffset, coolingTemperatureSetPoint, heatingTemperatureSetPoint, averageLoadAdjustmentPercentage, dutyCycle, \ + eventControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, ZCL_LOAD_CONTROL_EVENT_COMMAND_ID, "wvuwvuuuvvuuu", \ + issuerEventId, deviceClass, utilityEnrollmentGroup, startTime, durationInMinutes, criticalityLevel, \ + coolingTemperatureOffset, heatingTemperatureOffset, coolingTemperatureSetPoint, \ + heatingTemperatureSetPoint, averageLoadAdjustmentPercentage, dutyCycle, eventControl); /** @brief Command description for CancelLoadControlEvent * - * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. - * Command: CancelLoadControlEvent + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand + * Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. Command: + * CancelLoadControlEvent * @param issuerEventId uint32_t * @param deviceClass uint16_t * @param utilityEnrollmentGroup uint8_t * @param cancelControl uint8_t * @param effectiveTime uint32_t */ -#define emberAfFillCommandDemandResponseLoadControlClusterCancelLoadControlEvent(issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - cancelControl, \ - effectiveTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ - ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, \ - "wvuuw", \ - issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - cancelControl, \ - effectiveTime); - +#define emberAfFillCommandDemandResponseLoadControlClusterCancelLoadControlEvent( \ + issuerEventId, deviceClass, utilityEnrollmentGroup, cancelControl, effectiveTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID, "wvuuw", \ + issuerEventId, deviceClass, utilityEnrollmentGroup, cancelControl, effectiveTime); /** @brief Command description for CancelAllLoadControlEvents * - * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. - * Command: CancelAllLoadControlEvents + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand + * Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. Command: + * CancelAllLoadControlEvents * @param cancelControl uint8_t */ -#define emberAfFillCommandDemandResponseLoadControlClusterCancelAllLoadControlEvents(cancelControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ - ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, \ - "u", \ - cancelControl); - +#define emberAfFillCommandDemandResponseLoadControlClusterCancelAllLoadControlEvents(cancelControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID, "u", \ + cancelControl); /** @brief Command description for ReportEventStatus * - * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. - * Command: ReportEventStatus + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand + * Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. Command: + * ReportEventStatus * @param issuerEventId uint32_t * @param eventStatus uint8_t * @param eventStatusTime uint32_t @@ -8170,66 +5115,38 @@ * @param signatureType uint8_t * @param signature uint8_t* */ -#define emberAfFillCommandDemandResponseLoadControlClusterReportEventStatus(issuerEventId, \ - eventStatus, \ - eventStatusTime, \ - criticalityLevelApplied, \ - coolingTemperatureSetPointApplied, \ - heatingTemperatureSetPointApplied, \ - averageLoadAdjustmentPercentageApplied, \ - dutyCycleApplied, \ - eventControl, \ - signatureType, \ - signature) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ - ZCL_REPORT_EVENT_STATUS_COMMAND_ID, \ - "wuwuvvuuuub", \ - issuerEventId, \ - eventStatus, \ - eventStatusTime, \ - criticalityLevelApplied, \ - coolingTemperatureSetPointApplied, \ - heatingTemperatureSetPointApplied, \ - averageLoadAdjustmentPercentageApplied, \ - dutyCycleApplied, \ - eventControl, \ - signatureType, \ - signature, \ - 42); - +#define emberAfFillCommandDemandResponseLoadControlClusterReportEventStatus( \ + issuerEventId, eventStatus, eventStatusTime, criticalityLevelApplied, coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl, signatureType, \ + signature) \ + emberAfFillExternalBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ + ZCL_REPORT_EVENT_STATUS_COMMAND_ID, "wuwuvvuuuub", issuerEventId, eventStatus, eventStatusTime, criticalityLevelApplied, \ + coolingTemperatureSetPointApplied, heatingTemperatureSetPointApplied, averageLoadAdjustmentPercentageApplied, \ + dutyCycleApplied, eventControl, signatureType, signature, 42); /** @brief Command description for GetScheduledEvents * - * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. - * Command: GetScheduledEvents + * Cluster: Demand Response and Load Control, This cluster provides an interface to the functionality of Smart Energy Demand + * Response and Load Control. Devices targeted by this cluster include thermostats and devices that support load control. Command: + * GetScheduledEvents * @param startTime uint32_t * @param numberOfEvents uint8_t * @param issuerEventId uint32_t */ -#define emberAfFillCommandDemandResponseLoadControlClusterGetScheduledEvents(startTime, \ - numberOfEvents, \ - issuerEventId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, \ - ZCL_GET_SCHEDULED_EVENTS_COMMAND_ID, \ - "wuw", \ - startTime, \ - numberOfEvents, \ - issuerEventId); - +#define emberAfFillCommandDemandResponseLoadControlClusterGetScheduledEvents(startTime, numberOfEvents, issuerEventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, ZCL_GET_SCHEDULED_EVENTS_COMMAND_ID, "wuw", startTime, \ + numberOfEvents, issuerEventId); /** @} END Demand Response and Load Control Commands */ - /** @name Simple Metering Commands */ // @{ /** @brief This command is generated when the Client command GetProfile is received. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetProfileResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetProfileResponse * @param endTime uint32_t * @param status uint8_t * @param profileIntervalPeriod uint8_t @@ -8237,112 +5154,72 @@ * @param intervals uint8_t* * @param intervalsLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterGetProfileResponse(endTime, \ - status, \ - profileIntervalPeriod, \ - numberOfPeriodsDelivered, \ - intervals, \ - intervalsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, \ - "wuuub", \ - endTime, \ - status, \ - profileIntervalPeriod, \ - numberOfPeriodsDelivered, \ - intervals, \ - intervalsLen); - +#define emberAfFillCommandSimpleMeteringClusterGetProfileResponse(endTime, status, profileIntervalPeriod, \ + numberOfPeriodsDelivered, intervals, intervalsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_PROFILE_RESPONSE_COMMAND_ID, "wuuub", endTime, status, profileIntervalPeriod, \ + numberOfPeriodsDelivered, intervals, intervalsLen); /** @brief This command is used to request the ESI to mirror Metering Device data. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: RequestMirror + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: RequestMirror */ -#define emberAfFillCommandSimpleMeteringClusterRequestMirror() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_REQUEST_MIRROR_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSimpleMeteringClusterRequestMirror() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_MIRROR_COMMAND_ID, ""); /** @brief This command is used to request the ESI to remove its mirror of Metering Device data. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: RemoveMirror + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: RemoveMirror */ -#define emberAfFillCommandSimpleMeteringClusterRemoveMirror() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_REMOVE_MIRROR_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSimpleMeteringClusterRemoveMirror() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REMOVE_MIRROR_COMMAND_ID, ""); /** @brief This command is generated when the client command Request Fast Poll Mode is received. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: RequestFastPollModeResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: RequestFastPollModeResponse * @param appliedUpdatePeriod uint8_t * @param fastPollModeEndtime uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, \ - fastPollModeEndtime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, \ - "uw", \ - appliedUpdatePeriod, \ - fastPollModeEndtime); +#define emberAfFillCommandSimpleMeteringClusterRequestFastPollModeResponse(appliedUpdatePeriod, fastPollModeEndtime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID, "uw", appliedUpdatePeriod, fastPollModeEndtime); - -/** @brief This command is generated in response to a ScheduleSnapshot command, and is sent to confirm whether the requested snapshot schedule has been set up. +/** @brief This command is generated in response to a ScheduleSnapshot command, and is sent to confirm whether the requested + * snapshot schedule has been set up. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ScheduleSnapshotResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ScheduleSnapshotResponse * @param issuerEventId uint32_t * @param snapshotResponsePayload uint8_t* * @param snapshotResponsePayloadLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshotResponse(issuerEventId, \ - snapshotResponsePayload, \ - snapshotResponsePayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, \ - "wb", \ - issuerEventId, \ - snapshotResponsePayload, \ - snapshotResponsePayloadLen); - +#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshotResponse(issuerEventId, snapshotResponsePayload, \ + snapshotResponsePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID, "wb", issuerEventId, snapshotResponsePayload, \ + snapshotResponsePayloadLen); -/** @brief This command is generated in response to a TakeSnapshot command, and is sent to confirm whether the requested snapshot has been accepted and successfully taken. +/** @brief This command is generated in response to a TakeSnapshot command, and is sent to confirm whether the requested snapshot + * has been accepted and successfully taken. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: TakeSnapshotResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: TakeSnapshotResponse * @param snapshotId uint32_t * @param snapshotConfirmation uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterTakeSnapshotResponse(snapshotId, \ - snapshotConfirmation) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, \ - "wu", \ - snapshotId, \ - snapshotConfirmation); - +#define emberAfFillCommandSimpleMeteringClusterTakeSnapshotResponse(snapshotId, snapshotConfirmation) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID, "wu", snapshotId, snapshotConfirmation); /** @brief This command is generated in response to a GetSnapshot command. It is used to return a single snapshot to the client. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: PublishSnapshot + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: PublishSnapshot * @param snapshotId uint32_t * @param snapshotTime uint32_t * @param totalSnapshotsFound uint8_t @@ -8353,35 +5230,19 @@ * @param snapshotPayload uint8_t* * @param snapshotPayloadLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterPublishSnapshot(snapshotId, \ - snapshotTime, \ - totalSnapshotsFound, \ - commandIndex, \ - totalCommands, \ - snapshotCause, \ - snapshotPayloadType, \ - snapshotPayload, \ - snapshotPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, \ - "wwuuuwub", \ - snapshotId, \ - snapshotTime, \ - totalSnapshotsFound, \ - commandIndex, \ - totalCommands, \ - snapshotCause, \ - snapshotPayloadType, \ - snapshotPayload, \ - snapshotPayloadLen); - - -/** @brief This command is used to send the requested sample data to the client. It is generated in response to a GetSampledData command. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetSampledDataResponse +#define emberAfFillCommandSimpleMeteringClusterPublishSnapshot(snapshotId, snapshotTime, totalSnapshotsFound, commandIndex, \ + totalCommands, snapshotCause, snapshotPayloadType, snapshotPayload, \ + snapshotPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_PUBLISH_SNAPSHOT_COMMAND_ID, "wwuuuwub", snapshotId, snapshotTime, totalSnapshotsFound, \ + commandIndex, totalCommands, snapshotCause, snapshotPayloadType, snapshotPayload, \ + snapshotPayloadLen); + +/** @brief This command is used to send the requested sample data to the client. It is generated in response to a GetSampledData + * command. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetSampledDataResponse * @param sampleId uint16_t * @param sampleStartTime uint32_t * @param sampleType uint8_t @@ -8390,76 +5251,49 @@ * @param samples uint8_t* * @param samplesLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterGetSampledDataResponse(sampleId, \ - sampleStartTime, \ - sampleType, \ - sampleRequestInterval, \ - numberOfSamples, \ - samples, \ - samplesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, \ - "vwuvvb", \ - sampleId, \ - sampleStartTime, \ - sampleType, \ - sampleRequestInterval, \ - numberOfSamples, \ - samples, \ - samplesLen); - - -/** @brief ConfigureMirror is sent to the mirror once the mirror has been created. The command deals with the operational configuration of the Mirror. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ConfigureMirror +#define emberAfFillCommandSimpleMeteringClusterGetSampledDataResponse(sampleId, sampleStartTime, sampleType, \ + sampleRequestInterval, numberOfSamples, samples, samplesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID, "vwuvvb", sampleId, sampleStartTime, sampleType, \ + sampleRequestInterval, numberOfSamples, samples, samplesLen); + +/** @brief ConfigureMirror is sent to the mirror once the mirror has been created. The command deals with the operational + * configuration of the Mirror. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ConfigureMirror * @param issuerEventId uint32_t * @param reportingInterval uint32_t * @param mirrorNotificationReporting uint8_t * @param notificationScheme uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterConfigureMirror(issuerEventId, \ - reportingInterval, \ - mirrorNotificationReporting, \ - notificationScheme) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_CONFIGURE_MIRROR_COMMAND_ID, \ - "wxuu", \ - issuerEventId, \ - reportingInterval, \ - mirrorNotificationReporting, \ - notificationScheme); - - -/** @brief The ConfigureNotificationScheme is sent to the mirror once the mirror has been created. The command deals with the operational configuration of the Mirror and the device that reports to the mirror. No default schemes are allowed to be overwritten. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ConfigureNotificationScheme +#define emberAfFillCommandSimpleMeteringClusterConfigureMirror(issuerEventId, reportingInterval, mirrorNotificationReporting, \ + notificationScheme) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_MIRROR_COMMAND_ID, "wxuu", issuerEventId, reportingInterval, \ + mirrorNotificationReporting, notificationScheme); + +/** @brief The ConfigureNotificationScheme is sent to the mirror once the mirror has been created. The command deals with the + * operational configuration of the Mirror and the device that reports to the mirror. No default schemes are allowed to be + * overwritten. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ConfigureNotificationScheme * @param issuerEventId uint32_t * @param notificationScheme uint8_t * @param notificationFlagOrder uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationScheme(issuerEventId, \ - notificationScheme, \ - notificationFlagOrder) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, \ - "wuw", \ - issuerEventId, \ - notificationScheme, \ - notificationFlagOrder); +#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationScheme(issuerEventId, notificationScheme, \ + notificationFlagOrder) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID, "wuw", issuerEventId, notificationScheme, \ + notificationFlagOrder); - -/** @brief The ConfigureNotificationFlags command is used to set the commands relating to the bit value for each NotificationFlags attribute that the scheme is proposing to use. +/** @brief The ConfigureNotificationFlags command is used to set the commands relating to the bit value for each NotificationFlags + * attribute that the scheme is proposing to use. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ConfigureNotificationFlags + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ConfigureNotificationFlags * @param issuerEventId uint32_t * @param notificationScheme uint8_t * @param notificationFlagAttributeId uint16_t @@ -8469,318 +5303,204 @@ * @param commandIds uint8_t* * @param commandIdsLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationFlags(issuerEventId, \ - notificationScheme, \ - notificationFlagAttributeId, \ - clusterId, \ - manufacturerCode, \ - numberOfCommands, \ - commandIds, \ - commandIdsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, \ - "wuvvvub", \ - issuerEventId, \ - notificationScheme, \ - notificationFlagAttributeId, \ - clusterId, \ - manufacturerCode, \ - numberOfCommands, \ - commandIds, \ - commandIdsLen); - - -/** @brief The GetNotifiedMessage command is used only when a BOMD is being mirrored. This command provides a method for the BOMD to notify the Mirror message queue that it wants to receive commands that the Mirror has queued. The Notification flags set within the command shall inform the mirror of the commands that the BOMD is requesting. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetNotifiedMessage +#define emberAfFillCommandSimpleMeteringClusterConfigureNotificationFlags( \ + issuerEventId, notificationScheme, notificationFlagAttributeId, clusterId, manufacturerCode, numberOfCommands, commandIds, \ + commandIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID, "wuvvvub", issuerEventId, notificationScheme, \ + notificationFlagAttributeId, clusterId, manufacturerCode, numberOfCommands, commandIds, \ + commandIdsLen); + +/** @brief The GetNotifiedMessage command is used only when a BOMD is being mirrored. This command provides a method for the BOMD to + * notify the Mirror message queue that it wants to receive commands that the Mirror has queued. The Notification flags set within + * the command shall inform the mirror of the commands that the BOMD is requesting. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetNotifiedMessage * @param notificationScheme uint8_t * @param notificationFlagAttributeId uint16_t * @param notificationFlagsN uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterGetNotifiedMessage(notificationScheme, \ - notificationFlagAttributeId, \ - notificationFlagsN) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, \ - "uvw", \ - notificationScheme, \ - notificationFlagAttributeId, \ - notificationFlagsN); - +#define emberAfFillCommandSimpleMeteringClusterGetNotifiedMessage(notificationScheme, notificationFlagAttributeId, \ + notificationFlagsN) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID, "uvw", notificationScheme, notificationFlagAttributeId, \ + notificationFlagsN); /** @brief This command is transmitted by a Metering Device in response to a ChangeSupply command. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: SupplyStatusResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: SupplyStatusResponse * @param providerId uint32_t * @param issuerEventId uint32_t * @param implementationDateTime uint32_t * @param supplyStatus uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterSupplyStatusResponse(providerId, \ - issuerEventId, \ - implementationDateTime, \ - supplyStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, \ - "wwwu", \ - providerId, \ - issuerEventId, \ - implementationDateTime, \ - supplyStatus); - +#define emberAfFillCommandSimpleMeteringClusterSupplyStatusResponse(providerId, issuerEventId, implementationDateTime, \ + supplyStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID, "wwwu", providerId, issuerEventId, implementationDateTime, \ + supplyStatus); /** @brief This command is transmitted by a Metering Device in response to a StartSampling command. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: StartSamplingResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: StartSamplingResponse * @param sampleId uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterStartSamplingResponse(sampleId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, \ - "v", \ - sampleId); +#define emberAfFillCommandSimpleMeteringClusterStartSamplingResponse(sampleId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_START_SAMPLING_RESPONSE_COMMAND_ID, "v", sampleId); - -/** @brief The GetProfile command is generated when a client device wishes to retrieve a list of captured Energy, Gas or water consumption for profiling purposes. +/** @brief The GetProfile command is generated when a client device wishes to retrieve a list of captured Energy, Gas or water + * consumption for profiling purposes. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetProfile + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetProfile * @param intervalChannel uint8_t * @param endTime uint32_t * @param numberOfPeriods uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterGetProfile(intervalChannel, \ - endTime, \ - numberOfPeriods) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_PROFILE_COMMAND_ID, \ - "uwu", \ - intervalChannel, \ - endTime, \ - numberOfPeriods); - +#define emberAfFillCommandSimpleMeteringClusterGetProfile(intervalChannel, endTime, numberOfPeriods) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_PROFILE_COMMAND_ID, "uwu", intervalChannel, endTime, numberOfPeriods); -/** @brief The Request Mirror Response Command allows the ESI to inform a sleepy Metering Device it has the ability to store and mirror its data. +/** @brief The Request Mirror Response Command allows the ESI to inform a sleepy Metering Device it has the ability to store and + * mirror its data. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: RequestMirrorResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: RequestMirrorResponse * @param endpointId uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterRequestMirrorResponse(endpointId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID, \ - "v", \ - endpointId); +#define emberAfFillCommandSimpleMeteringClusterRequestMirrorResponse(endpointId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID, "v", endpointId); - -/** @brief The Mirror Removed Command allows the ESI to inform a sleepy Metering Device mirroring support has been removed or halted. +/** @brief The Mirror Removed Command allows the ESI to inform a sleepy Metering Device mirroring support has been removed or + * halted. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: MirrorRemoved + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: MirrorRemoved * @param endpointId uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterMirrorRemoved(endpointId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_MIRROR_REMOVED_COMMAND_ID, \ - "v", \ - endpointId); - +#define emberAfFillCommandSimpleMeteringClusterMirrorRemoved(endpointId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_MIRROR_REMOVED_COMMAND_ID, "v", endpointId); -/** @brief The Request Fast Poll Mode command is generated when the metering client wishes to receive near real-time updates of InstantaneousDemand. +/** @brief The Request Fast Poll Mode command is generated when the metering client wishes to receive near real-time updates of + * InstantaneousDemand. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: RequestFastPollMode + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: RequestFastPollMode * @param fastPollUpdatePeriod uint8_t * @param duration uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterRequestFastPollMode(fastPollUpdatePeriod, \ - duration) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID, \ - "uu", \ - fastPollUpdatePeriod, \ - duration); - +#define emberAfFillCommandSimpleMeteringClusterRequestFastPollMode(fastPollUpdatePeriod, duration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID, "uu", fastPollUpdatePeriod, duration); /** @brief This command is used to set up a schedule of when the device shall create snapshot data. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ScheduleSnapshot + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ScheduleSnapshot * @param issuerEventId uint32_t * @param commandIndex uint8_t * @param commandCount uint8_t * @param snapshotSchedulePayload uint8_t* * @param snapshotSchedulePayloadLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshot(issuerEventId, \ - commandIndex, \ - commandCount, \ - snapshotSchedulePayload, \ - snapshotSchedulePayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID, \ - "wuub", \ - issuerEventId, \ - commandIndex, \ - commandCount, \ - snapshotSchedulePayload, \ - snapshotSchedulePayloadLen); - +#define emberAfFillCommandSimpleMeteringClusterScheduleSnapshot(issuerEventId, commandIndex, commandCount, \ + snapshotSchedulePayload, snapshotSchedulePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID, "wuub", issuerEventId, commandIndex, commandCount, \ + snapshotSchedulePayload, snapshotSchedulePayloadLen); /** @brief This command is used to instruct the cluster server to take a single snapshot. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: TakeSnapshot + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: TakeSnapshot * @param snapshotCause uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterTakeSnapshot(snapshotCause) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_TAKE_SNAPSHOT_COMMAND_ID, \ - "w", \ - snapshotCause); - +#define emberAfFillCommandSimpleMeteringClusterTakeSnapshot(snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_TAKE_SNAPSHOT_COMMAND_ID, "w", snapshotCause); /** @brief This command is used to request snapshot data from the cluster server. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetSnapshot + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetSnapshot * @param earliestStartTime uint32_t * @param latestEndTime uint32_t * @param snapshotOffset uint8_t * @param snapshotCause uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterGetSnapshot(earliestStartTime, \ - latestEndTime, \ - snapshotOffset, \ - snapshotCause) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_SNAPSHOT_COMMAND_ID, \ - "wwuw", \ - earliestStartTime, \ - latestEndTime, \ - snapshotOffset, \ - snapshotCause); - - -/** @brief The sampling mechanism allows a set of samples of the specified type of data to be taken, commencing at the stipulated start time. This mechanism may run concurrently with the capturing of profile data, and may refer the same parameters, albeit possibly at a different sampling rate. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: StartSampling +#define emberAfFillCommandSimpleMeteringClusterGetSnapshot(earliestStartTime, latestEndTime, snapshotOffset, snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SNAPSHOT_COMMAND_ID, "wwuw", earliestStartTime, latestEndTime, snapshotOffset, \ + snapshotCause); + +/** @brief The sampling mechanism allows a set of samples of the specified type of data to be taken, commencing at the stipulated + * start time. This mechanism may run concurrently with the capturing of profile data, and may refer the same parameters, albeit + * possibly at a different sampling rate. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: StartSampling * @param issuerEventId uint32_t * @param startSamplingTime uint32_t * @param sampleType uint8_t * @param sampleRequestInterval uint16_t * @param maxNumberOfSamples uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterStartSampling(issuerEventId, \ - startSamplingTime, \ - sampleType, \ - sampleRequestInterval, \ - maxNumberOfSamples) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_START_SAMPLING_COMMAND_ID, \ - "wwuvv", \ - issuerEventId, \ - startSamplingTime, \ - sampleType, \ - sampleRequestInterval, \ - maxNumberOfSamples); - - -/** @brief This command is used to request sampled data from the server. Note that it is the responsibility of the client to ensure that it does not request more samples than can be held in a single command payload. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: GetSampledData +#define emberAfFillCommandSimpleMeteringClusterStartSampling(issuerEventId, startSamplingTime, sampleType, sampleRequestInterval, \ + maxNumberOfSamples) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_START_SAMPLING_COMMAND_ID, "wwuvv", issuerEventId, startSamplingTime, sampleType, \ + sampleRequestInterval, maxNumberOfSamples); + +/** @brief This command is used to request sampled data from the server. Note that it is the responsibility of the client to ensure + * that it does not request more samples than can be held in a single command payload. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: GetSampledData * @param sampleId uint16_t * @param earliestSampleTime uint32_t * @param sampleType uint8_t * @param numberOfSamples uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterGetSampledData(sampleId, \ - earliestSampleTime, \ - sampleType, \ - numberOfSamples) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_GET_SAMPLED_DATA_COMMAND_ID, \ - "vwuv", \ - sampleId, \ - earliestSampleTime, \ - sampleType, \ - numberOfSamples); - +#define emberAfFillCommandSimpleMeteringClusterGetSampledData(sampleId, earliestSampleTime, sampleType, numberOfSamples) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_GET_SAMPLED_DATA_COMMAND_ID, "vwuv", sampleId, earliestSampleTime, sampleType, numberOfSamples); /** @brief This command is sent in response to the ReportAttribute command when the MirrorReporting attribute is set. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: MirrorReportAttributeResponse + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: MirrorReportAttributeResponse * @param notificationScheme uint8_t * @param notificationFlags uint8_t* * @param notificationFlagsLen uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterMirrorReportAttributeResponse(notificationScheme, \ - notificationFlags, \ - notificationFlagsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ID, \ - "ub", \ - notificationScheme, \ - notificationFlags, \ - notificationFlagsLen); - +#define emberAfFillCommandSimpleMeteringClusterMirrorReportAttributeResponse(notificationScheme, notificationFlags, \ + notificationFlagsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ID, "ub", notificationScheme, notificationFlags, \ + notificationFlagsLen); /** @brief The ResetLoadLimitCounter command shall cause the LoadLimitCounter attribute to be reset. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ResetLoadLimitCounter + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ResetLoadLimitCounter * @param providerId uint32_t * @param issuerEventId uint32_t */ -#define emberAfFillCommandSimpleMeteringClusterResetLoadLimitCounter(providerId, \ - issuerEventId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID, \ - "ww", \ - providerId, \ - issuerEventId); - +#define emberAfFillCommandSimpleMeteringClusterResetLoadLimitCounter(providerId, issuerEventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID, "ww", providerId, issuerEventId); -/** @brief This command is sent from the Head-end or ESI to the Metering Device to instruct it to change the status of the valve or load switch, i.e. the supply. +/** @brief This command is sent from the Head-end or ESI to the Metering Device to instruct it to change the status of the valve or + * load switch, i.e. the supply. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: ChangeSupply + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: ChangeSupply * @param providerId uint32_t * @param issuerEventId uint32_t * @param requestDateTime uint32_t @@ -8788,71 +5508,44 @@ * @param proposedSupplyStatus uint8_t * @param supplyControlBits uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterChangeSupply(providerId, \ - issuerEventId, \ - requestDateTime, \ - implementationDateTime, \ - proposedSupplyStatus, \ - supplyControlBits) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_CHANGE_SUPPLY_COMMAND_ID, \ - "wwwwuu", \ - providerId, \ - issuerEventId, \ - requestDateTime, \ - implementationDateTime, \ - proposedSupplyStatus, \ - supplyControlBits); - - -/** @brief This command is a simplified version of the ChangeSupply command, intended to be sent from an IHD to a meter as the consequence of a user action on the IHD. Its purpose is to provide a local disconnection/reconnection button on the IHD in addition to the one on the meter. - * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: LocalChangeSupply +#define emberAfFillCommandSimpleMeteringClusterChangeSupply(providerId, issuerEventId, requestDateTime, implementationDateTime, \ + proposedSupplyStatus, supplyControlBits) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_CHANGE_SUPPLY_COMMAND_ID, "wwwwuu", providerId, issuerEventId, requestDateTime, \ + implementationDateTime, proposedSupplyStatus, supplyControlBits); + +/** @brief This command is a simplified version of the ChangeSupply command, intended to be sent from an IHD to a meter as the + * consequence of a user action on the IHD. Its purpose is to provide a local disconnection/reconnection button on the IHD in + * addition to the one on the meter. + * + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: LocalChangeSupply * @param proposedSupplyStatus uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterLocalChangeSupply(proposedSupplyStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID, \ - "u", \ - proposedSupplyStatus); - +#define emberAfFillCommandSimpleMeteringClusterLocalChangeSupply(proposedSupplyStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID, "u", proposedSupplyStatus); /** @brief This command is used to specify the required status of the supply following the occurance of certain events on the meter. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: SetSupplyStatus + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: SetSupplyStatus * @param issuerEventId uint32_t * @param supplyTamperState uint8_t * @param supplyDepletionState uint8_t * @param supplyUncontrolledFlowState uint8_t * @param loadLimitSupplyState uint8_t */ -#define emberAfFillCommandSimpleMeteringClusterSetSupplyStatus(issuerEventId, \ - supplyTamperState, \ - supplyDepletionState, \ - supplyUncontrolledFlowState, \ - loadLimitSupplyState) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_SET_SUPPLY_STATUS_COMMAND_ID, \ - "wuuuu", \ - issuerEventId, \ - supplyTamperState, \ - supplyDepletionState, \ - supplyUncontrolledFlowState, \ - loadLimitSupplyState); - +#define emberAfFillCommandSimpleMeteringClusterSetSupplyStatus(issuerEventId, supplyTamperState, supplyDepletionState, \ + supplyUncontrolledFlowState, loadLimitSupplyState) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SET_SUPPLY_STATUS_COMMAND_ID, "wuuuu", issuerEventId, supplyTamperState, supplyDepletionState, \ + supplyUncontrolledFlowState, loadLimitSupplyState); /** @brief This command is used to update the 'Uncontrolled Flow Rate' configuration data used by flow meters. * - * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and potentially Thermal metering devices. - * Command: SetUncontrolledFlowThreshold + * Cluster: Simple Metering, The Metering Cluster provides a mechanism to retrieve usage information from Electric, Gas, Water, and + * potentially Thermal metering devices. Command: SetUncontrolledFlowThreshold * @param providerId uint32_t * @param issuerEventId uint32_t * @param uncontrolledFlowThreshold uint16_t @@ -8862,32 +5555,16 @@ * @param stabilisationPeriod uint8_t * @param measurementPeriod uint16_t */ -#define emberAfFillCommandSimpleMeteringClusterSetUncontrolledFlowThreshold(providerId, \ - issuerEventId, \ - uncontrolledFlowThreshold, \ - unitOfMeasure, \ - multiplier, \ - divisor, \ - stabilisationPeriod, \ - measurementPeriod) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SIMPLE_METERING_CLUSTER_ID, \ - ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, \ - "wwvuvvuv", \ - providerId, \ - issuerEventId, \ - uncontrolledFlowThreshold, \ - unitOfMeasure, \ - multiplier, \ - divisor, \ - stabilisationPeriod, \ - measurementPeriod); - +#define emberAfFillCommandSimpleMeteringClusterSetUncontrolledFlowThreshold(providerId, issuerEventId, uncontrolledFlowThreshold, \ + unitOfMeasure, multiplier, divisor, \ + stabilisationPeriod, measurementPeriod) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SIMPLE_METERING_CLUSTER_ID, \ + ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID, "wwvuvvuv", providerId, issuerEventId, \ + uncontrolledFlowThreshold, unitOfMeasure, multiplier, divisor, stabilisationPeriod, \ + measurementPeriod); /** @} END Simple Metering Commands */ - /** @name Messaging Commands */ // @{ /** @brief Command description for DisplayMessage @@ -8901,24 +5578,11 @@ * @param message uint8_t* * @param optionalExtendedMessageControl uint8_t */ -#define emberAfFillCommandMessagingClusterDisplayMessage(messageId, \ - messageControl, \ - startTime, \ - durationInMinutes, \ - message, \ - optionalExtendedMessageControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_DISPLAY_MESSAGE_COMMAND_ID, \ - "wuwvsu", \ - messageId, \ - messageControl, \ - startTime, \ - durationInMinutes, \ - message, \ - optionalExtendedMessageControl); - +#define emberAfFillCommandMessagingClusterDisplayMessage(messageId, messageControl, startTime, durationInMinutes, message, \ + optionalExtendedMessageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_DISPLAY_MESSAGE_COMMAND_ID, "wuwvsu", messageId, messageControl, startTime, durationInMinutes, \ + message, optionalExtendedMessageControl); /** @brief The CancelMessage command provides the ability to cancel the sending or acceptance of previously sent messages. * @@ -8927,16 +5591,9 @@ * @param messageId uint32_t * @param messageControl uint8_t */ -#define emberAfFillCommandMessagingClusterCancelMessage(messageId, \ - messageControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_CANCEL_MESSAGE_COMMAND_ID, \ - "wu", \ - messageId, \ - messageControl); - +#define emberAfFillCommandMessagingClusterCancelMessage(messageId, messageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_CANCEL_MESSAGE_COMMAND_ID, "wu", messageId, messageControl); /** @brief The DisplayProtected Message command is for use with messages that are protected by a password or PIN. * @@ -8949,54 +5606,35 @@ * @param message uint8_t* * @param optionalExtendedMessageControl uint8_t */ -#define emberAfFillCommandMessagingClusterDisplayProtectedMessage(messageId, \ - messageControl, \ - startTime, \ - durationInMinutes, \ - message, \ - optionalExtendedMessageControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, \ - "wuwvsu", \ - messageId, \ - messageControl, \ - startTime, \ - durationInMinutes, \ - message, \ - optionalExtendedMessageControl); - - -/** @brief The CancelAllMessages command indicates to a client device that it should cancel all display messages currently held by it. +#define emberAfFillCommandMessagingClusterDisplayProtectedMessage(messageId, messageControl, startTime, durationInMinutes, \ + message, optionalExtendedMessageControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID, "wuwvsu", messageId, messageControl, startTime, \ + durationInMinutes, message, optionalExtendedMessageControl); + +/** @brief The CancelAllMessages command indicates to a client device that it should cancel all display messages currently held by + * it. * * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. * Command: CancelAllMessages * @param implementationDateTime uint32_t */ -#define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, \ - "w", \ - implementationDateTime); - +#define emberAfFillCommandMessagingClusterCancelAllMessages(implementationDateTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID, "w", implementationDateTime); /** @brief Command description for GetLastMessage * * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. * Command: GetLastMessage */ -#define emberAfFillCommandMessagingClusterGetLastMessage() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_GET_LAST_MESSAGE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandMessagingClusterGetLastMessage() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_GET_LAST_MESSAGE_COMMAND_ID, ""); -/** @brief The Message Confirmation command provides an indication that a Utility Customer has acknowledged and/or accepted the contents of a previously sent message. Enhanced Message Confirmation commands shall contain an answer of 'NO', 'YES' and/or a message confirmation string. +/** @brief The Message Confirmation command provides an indication that a Utility Customer has acknowledged and/or accepted the + * contents of a previously sent message. Enhanced Message Confirmation commands shall contain an answer of 'NO', 'YES' and/or a + * message confirmation string. * * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. * Command: MessageConfirmation @@ -9005,42 +5643,30 @@ * @param messageConfirmationControl uint8_t * @param messageResponse uint8_t* */ -#define emberAfFillCommandMessagingClusterMessageConfirmation(messageId, \ - confirmationTime, \ - messageConfirmationControl, \ - messageResponse) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_MESSAGE_CONFIRMATION_COMMAND_ID, \ - "wwus", \ - messageId, \ - confirmationTime, \ - messageConfirmationControl, \ - messageResponse); +#define emberAfFillCommandMessagingClusterMessageConfirmation(messageId, confirmationTime, messageConfirmationControl, \ + messageResponse) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_MESSAGE_CONFIRMATION_COMMAND_ID, "wwus", messageId, confirmationTime, \ + messageConfirmationControl, messageResponse); - -/** @brief This command initiates the return of the first (and maybe only) Cancel All Messages command held on the associated server, and which has an implementation time equal to or later than the value indicated in the payload. +/** @brief This command initiates the return of the first (and maybe only) Cancel All Messages command held on the associated + * server, and which has an implementation time equal to or later than the value indicated in the payload. * * Cluster: Messaging, This cluster provides an interface for passing text messages between SE devices. * Command: GetMessageCancellation * @param earliestImplementationTime uint32_t */ -#define emberAfFillCommandMessagingClusterGetMessageCancellation(earliestImplementationTime) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MESSAGING_CLUSTER_ID, \ - ZCL_GET_MESSAGE_CANCELLATION_COMMAND_ID, \ - "w", \ - earliestImplementationTime); - +#define emberAfFillCommandMessagingClusterGetMessageCancellation(earliestImplementationTime) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_MESSAGING_CLUSTER_ID, \ + ZCL_GET_MESSAGE_CANCELLATION_COMMAND_ID, "w", earliestImplementationTime); /** @} END Messaging Commands */ - /** @name Tunneling Commands */ // @{ -/** @brief RequestTunnel is the client command used to setup a tunnel association with the server. The request payload specifies the protocol identifier for the requested tunnel, a manufacturer code in case of proprietary protocols and the use of flow control for streaming protocols. +/** @brief RequestTunnel is the client command used to setup a tunnel association with the server. The request payload specifies the + * protocol identifier for the requested tunnel, a manufacturer code in case of proprietary protocols and the use of flow control + * for streaming protocols. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: RequestTunnel @@ -9049,37 +5675,26 @@ * @param flowControlSupport uint8_t * @param maximumIncomingTransferSize uint16_t */ -#define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, \ - manufacturerCode, \ - flowControlSupport, \ - maximumIncomingTransferSize) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_REQUEST_TUNNEL_COMMAND_ID, \ - "uvuv", \ - protocolId, \ - manufacturerCode, \ - flowControlSupport, \ - maximumIncomingTransferSize); - +#define emberAfFillCommandTunnelingClusterRequestTunnel(protocolId, manufacturerCode, flowControlSupport, \ + maximumIncomingTransferSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_REQUEST_TUNNEL_COMMAND_ID, "uvuv", protocolId, manufacturerCode, flowControlSupport, \ + maximumIncomingTransferSize); -/** @brief Client command used to close the tunnel with the server. The parameter in the payload specifies the tunnel identifier of the tunnel that has to be closed. The server leaves the tunnel open and the assigned resources allocated until the client sends the CloseTunnel command or the CloseTunnelTimeout fires. +/** @brief Client command used to close the tunnel with the server. The parameter in the payload specifies the tunnel identifier of + * the tunnel that has to be closed. The server leaves the tunnel open and the assigned resources allocated until the client sends + * the CloseTunnel command or the CloseTunnelTimeout fires. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: CloseTunnel * @param tunnelId uint16_t */ -#define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_CLOSE_TUNNEL_COMMAND_ID, \ - "v", \ - tunnelId); +#define emberAfFillCommandTunnelingClusterCloseTunnel(tunnelId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_CLOSE_TUNNEL_COMMAND_ID, "v", tunnelId); - -/** @brief Command that indicates (if received) that the client has sent data to the server. The data itself is contained within the payload. +/** @brief Command that indicates (if received) that the client has sent data to the server. The data itself is contained within the + * payload. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: TransferDataClientToServer @@ -9087,72 +5702,51 @@ * @param data uint8_t* * @param dataLen uint16_t */ -#define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, \ - data, \ - dataLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ - "vb", \ - tunnelId, \ - data, \ - dataLen); - +#define emberAfFillCommandTunnelingClusterTransferDataClientToServer(tunnelId, data, dataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "vb", tunnelId, data, dataLen); -/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. +/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is + * wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does + * not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData + * command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a + * proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received + * contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: TransferDataErrorClientToServer * @param tunnelId uint16_t * @param transferDataStatus uint8_t */ -#define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, \ - transferDataStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, \ - "vu", \ - tunnelId, \ - transferDataStatus); +#define emberAfFillCommandTunnelingClusterTransferDataErrorClientToServer(tunnelId, transferDataStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID, "vu", tunnelId, transferDataStatus); - -/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of octets that may still be received by the receiver. +/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the + * client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of + * octets that may still be received by the receiver. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: AckTransferDataClientToServer * @param tunnelId uint16_t * @param numberOfBytesLeft uint16_t */ -#define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, \ - numberOfBytesLeft) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ - "vv", \ - tunnelId, \ - numberOfBytesLeft); - +#define emberAfFillCommandTunnelingClusterAckTransferDataClientToServer(tunnelId, numberOfBytesLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID, "vv", tunnelId, numberOfBytesLeft); -/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. +/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to + * indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space + * is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: ReadyDataClientToServer * @param tunnelId uint16_t * @param numberOfOctetsLeft uint16_t */ -#define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, \ - numberOfOctetsLeft) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, \ - "vv", \ - tunnelId, \ - numberOfOctetsLeft); - +#define emberAfFillCommandTunnelingClusterReadyDataClientToServer(tunnelId, numberOfOctetsLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID, "vv", tunnelId, numberOfOctetsLeft); /** @brief Get Supported Tunnel Protocols is the client command used to determine the Tunnel protocols supported on another device. * @@ -9160,16 +5754,13 @@ * Command: GetSupportedTunnelProtocols * @param protocolOffset uint8_t */ -#define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, \ - "u", \ - protocolOffset); +#define emberAfFillCommandTunnelingClusterGetSupportedTunnelProtocols(protocolOffset) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID, "u", protocolOffset); - -/** @brief RequestTunnelResponse is sent by the server in response to a RequestTunnel command previously received from the client. The response contains the status of the RequestTunnel command and a tunnel identifier corresponding to the tunnel that has been set-up in the server in case of success. +/** @brief RequestTunnelResponse is sent by the server in response to a RequestTunnel command previously received from the client. + * The response contains the status of the RequestTunnel command and a tunnel identifier corresponding to the tunnel that has been + * set-up in the server in case of success. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: RequestTunnelResponse @@ -9177,18 +5768,9 @@ * @param tunnelStatus uint8_t * @param maximumIncomingTransferSize uint16_t */ -#define emberAfFillCommandTunnelingClusterRequestTunnelResponse(tunnelId, \ - tunnelStatus, \ - maximumIncomingTransferSize) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID, \ - "vuv", \ - tunnelId, \ - tunnelStatus, \ - maximumIncomingTransferSize); - +#define emberAfFillCommandTunnelingClusterRequestTunnelResponse(tunnelId, tunnelStatus, maximumIncomingTransferSize) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID, "vuv", tunnelId, tunnelStatus, maximumIncomingTransferSize); /** @brief Command that transfers data from server to the client. The data itself has to be placed within the payload. * @@ -9198,74 +5780,55 @@ * @param data uint8_t* * @param dataLen uint16_t */ -#define emberAfFillCommandTunnelingClusterTransferDataServerToClient(tunnelId, \ - data, \ - dataLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ - "vb", \ - tunnelId, \ - data, \ - dataLen); +#define emberAfFillCommandTunnelingClusterTransferDataServerToClient(tunnelId, data, dataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, "vb", tunnelId, data, dataLen); - -/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. +/** @brief This command is generated by the receiver of a TransferData command if the tunnel status indicates that something is + * wrong. There are two three cases in which TransferDataError is sent: (1) The TransferData received contains a TunnelID that does + * not match to any of the active tunnels of the receiving device. This could happen if a (sleeping) device sends a TransferData + * command to a tunnel that has been closed by the server after the CloseTunnelTimeout. (2) The TransferData received contains a + * proper TunnelID of an active tunnel, but the device sending the data does not match to it. (3) The TransferData received + * contains more data than indicated by the MaximumIncomingTransferSize of the receiving device. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: TransferDataErrorServerToClient * @param tunnelId uint16_t * @param transferDataStatus uint8_t */ -#define emberAfFillCommandTunnelingClusterTransferDataErrorServerToClient(tunnelId, \ - transferDataStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_TRANSFER_DATA_ERROR_SERVER_TO_CLIENT_COMMAND_ID, \ - "vu", \ - tunnelId, \ - transferDataStatus); - +#define emberAfFillCommandTunnelingClusterTransferDataErrorServerToClient(tunnelId, transferDataStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TRANSFER_DATA_ERROR_SERVER_TO_CLIENT_COMMAND_ID, "vu", tunnelId, transferDataStatus); -/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of octets that may still be received by the receiver. +/** @brief Command sent in response to each TransferData command in case - and only in case - flow control has been requested by the + * client in the TunnelRequest command and is supported by both tunnel endpoints. The response payload indicates the number of + * octets that may still be received by the receiver. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: AckTransferDataServerToClient * @param tunnelId uint16_t * @param numberOfBytesLeft uint16_t */ -#define emberAfFillCommandTunnelingClusterAckTransferDataServerToClient(tunnelId, \ - numberOfBytesLeft) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ - "vv", \ - tunnelId, \ - numberOfBytesLeft); +#define emberAfFillCommandTunnelingClusterAckTransferDataServerToClient(tunnelId, numberOfBytesLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID, "vv", tunnelId, numberOfBytesLeft); - -/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. +/** @brief The ReadyData command is generated - after a receiver had to stop the dataflow using the AckTransferData(0) command - to + * indicate that the device is now ready to continue receiving data. The parameter NumberOfOctetsLeft gives a hint on how much space + * is left for the next data transfer. The ReadyData command is only issued if flow control is enabled. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: ReadyDataServerToClient * @param tunnelId uint16_t * @param numberOfOctetsLeft uint16_t */ -#define emberAfFillCommandTunnelingClusterReadyDataServerToClient(tunnelId, \ - numberOfOctetsLeft) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID, \ - "vv", \ - tunnelId, \ - numberOfOctetsLeft); - +#define emberAfFillCommandTunnelingClusterReadyDataServerToClient(tunnelId, numberOfOctetsLeft) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID, "vv", tunnelId, numberOfOctetsLeft); -/** @brief Supported Tunnel Protocol Response is sent in response to a Get Supported Tunnel Protocols command previously received. The response contains a list of Tunnel protocols supported by the device; the payload of the response should be capable of holding up to 16 protocols. +/** @brief Supported Tunnel Protocol Response is sent in response to a Get Supported Tunnel Protocols command previously received. + * The response contains a list of Tunnel protocols supported by the device; the payload of the response should be capable of + * holding up to 16 protocols. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: SupportedTunnelProtocolsResponse @@ -9274,63 +5837,42 @@ * @param protocolList uint8_t* * @param protocolListLen uint16_t */ -#define emberAfFillCommandTunnelingClusterSupportedTunnelProtocolsResponse(protocolListComplete, \ - protocolCount, \ - protocolList, \ - protocolListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID, \ - "uub", \ - protocolListComplete, \ - protocolCount, \ - protocolList, \ - protocolListLen); +#define emberAfFillCommandTunnelingClusterSupportedTunnelProtocolsResponse(protocolListComplete, protocolCount, protocolList, \ + protocolListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID, "uub", protocolListComplete, protocolCount, \ + protocolList, protocolListLen); - -/** @brief TunnelClosureNotification is sent by the server to indicate that a tunnel has been closed due to expiration of a CloseTunnelTimeout. +/** @brief TunnelClosureNotification is sent by the server to indicate that a tunnel has been closed due to expiration of a + * CloseTunnelTimeout. * * Cluster: Tunneling, The tunneling cluster provides an interface for tunneling protocols. * Command: TunnelClosureNotification * @param tunnelId uint16_t */ -#define emberAfFillCommandTunnelingClusterTunnelClosureNotification(tunnelId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_TUNNELING_CLUSTER_ID, \ - ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID, \ - "v", \ - tunnelId); - +#define emberAfFillCommandTunnelingClusterTunnelClosureNotification(tunnelId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_TUNNELING_CLUSTER_ID, \ + ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID, "v", tunnelId); /** @} END Tunneling Commands */ - /** @name Prepayment Commands */ // @{ /** @brief This command is sent to the Metering Device to activate the use of any Emergency Credit available on the Metering Device. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: SelectAvailableEmergencyCredit + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: SelectAvailableEmergencyCredit * @param commandIssueDateTime uint32_t * @param originatingDevice uint8_t */ -#define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, \ - originatingDevice) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, \ - "wu", \ - commandIssueDateTime, \ - originatingDevice); - +#define emberAfFillCommandPrepaymentClusterSelectAvailableEmergencyCredit(commandIssueDateTime, originatingDevice) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID, "wu", commandIssueDateTime, originatingDevice); /** @brief The ChangeDebt command is send to the Metering Device to change the fuel or Non fuel debt values. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: ChangeDebt + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: ChangeDebt * @param issuerEventId uint32_t * @param debtLabel uint8_t* * @param debtAmount uint32_t @@ -9342,259 +5884,153 @@ * @param debtRecoveryAmount uint32_t * @param debtRecoveryBalancePercentage uint16_t */ -#define emberAfFillCommandPrepaymentClusterChangeDebt(issuerEventId, \ - debtLabel, \ - debtAmount, \ - debtRecoveryMethod, \ - debtAmountType, \ - debtRecoveryStartTime, \ - debtRecoveryCollectionTime, \ - debtRecoveryFrequency, \ - debtRecoveryAmount, \ - debtRecoveryBalancePercentage) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CHANGE_DEBT_COMMAND_ID, \ - "wswuuwvuwv", \ - issuerEventId, \ - debtLabel, \ - debtAmount, \ - debtRecoveryMethod, \ - debtAmountType, \ - debtRecoveryStartTime, \ - debtRecoveryCollectionTime, \ - debtRecoveryFrequency, \ - debtRecoveryAmount, \ - debtRecoveryBalancePercentage); - +#define emberAfFillCommandPrepaymentClusterChangeDebt(issuerEventId, debtLabel, debtAmount, debtRecoveryMethod, debtAmountType, \ + debtRecoveryStartTime, debtRecoveryCollectionTime, debtRecoveryFrequency, \ + debtRecoveryAmount, debtRecoveryBalancePercentage) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_DEBT_COMMAND_ID, "wswuuwvuwv", issuerEventId, debtLabel, debtAmount, debtRecoveryMethod, \ + debtAmountType, debtRecoveryStartTime, debtRecoveryCollectionTime, debtRecoveryFrequency, \ + debtRecoveryAmount, debtRecoveryBalancePercentage); /** @brief This command is a method to set up the parameters for the emergency credit. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: EmergencyCreditSetup + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: EmergencyCreditSetup * @param issuerEventId uint32_t * @param startTime uint32_t * @param emergencyCreditLimit uint32_t * @param emergencyCreditThreshold uint32_t */ -#define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, \ - startTime, \ - emergencyCreditLimit, \ - emergencyCreditThreshold) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, \ - "wwww", \ - issuerEventId, \ - startTime, \ - emergencyCreditLimit, \ - emergencyCreditThreshold); - - -/** @brief The ConsumerTopUp command is used by the IPD and the ESI as a method of applying credit top up values to the prepayment meter. - * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: ConsumerTopUp +#define emberAfFillCommandPrepaymentClusterEmergencyCreditSetup(issuerEventId, startTime, emergencyCreditLimit, \ + emergencyCreditThreshold) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID, "wwww", issuerEventId, startTime, emergencyCreditLimit, \ + emergencyCreditThreshold); + +/** @brief The ConsumerTopUp command is used by the IPD and the ESI as a method of applying credit top up values to the prepayment + * meter. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: ConsumerTopUp * @param originatingDevice uint8_t * @param topUpCode uint8_t* */ -#define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, \ - topUpCode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CONSUMER_TOP_UP_COMMAND_ID, \ - "us", \ - originatingDevice, \ - topUpCode); - +#define emberAfFillCommandPrepaymentClusterConsumerTopUp(originatingDevice, topUpCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CONSUMER_TOP_UP_COMMAND_ID, "us", originatingDevice, topUpCode); /** @brief The CreditAdjustment command is sent to update the accounting base for the Prepayment meter. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: CreditAdjustment + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: CreditAdjustment * @param issuerEventId uint32_t * @param startTime uint32_t * @param creditAdjustmentType uint8_t * @param creditAdjustmentValue uint32_t */ -#define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, \ - startTime, \ - creditAdjustmentType, \ - creditAdjustmentValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, \ - "wwuw", \ - issuerEventId, \ - startTime, \ - creditAdjustmentType, \ - creditAdjustmentValue); - +#define emberAfFillCommandPrepaymentClusterCreditAdjustment(issuerEventId, startTime, creditAdjustmentType, creditAdjustmentValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CREDIT_ADJUSTMENT_COMMAND_ID, "wwuw", issuerEventId, startTime, creditAdjustmentType, \ + creditAdjustmentValue); /** @brief This command is sent to a Metering Device to instruct it to change its mode of operation. i.e. from Credit to Prepayment. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: ChangePaymentMode + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: ChangePaymentMode * @param providerId uint32_t * @param issuerEventId uint32_t * @param implementationDateTime uint32_t * @param proposedPaymentControlConfiguration uint16_t * @param cutOffValue uint32_t */ -#define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, \ - issuerEventId, \ - implementationDateTime, \ - proposedPaymentControlConfiguration, \ - cutOffValue) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, \ - "wwwvw", \ - providerId, \ - issuerEventId, \ - implementationDateTime, \ - proposedPaymentControlConfiguration, \ - cutOffValue); - +#define emberAfFillCommandPrepaymentClusterChangePaymentMode(providerId, issuerEventId, implementationDateTime, \ + proposedPaymentControlConfiguration, cutOffValue) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID, "wwwvw", providerId, issuerEventId, implementationDateTime, \ + proposedPaymentControlConfiguration, cutOffValue); /** @brief This command is used to request the cluster server for snapshot data. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: GetPrepaySnapshot + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: GetPrepaySnapshot * @param earliestStartTime uint32_t * @param latestEndTime uint32_t * @param snapshotOffset uint8_t * @param snapshotCause uint32_t */ -#define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, \ - latestEndTime, \ - snapshotOffset, \ - snapshotCause) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, \ - "wwuw", \ - earliestStartTime, \ - latestEndTime, \ - snapshotOffset, \ - snapshotCause); - +#define emberAfFillCommandPrepaymentClusterGetPrepaySnapshot(earliestStartTime, latestEndTime, snapshotOffset, snapshotCause) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID, "wwuw", earliestStartTime, latestEndTime, snapshotOffset, \ + snapshotCause); /** @brief This command is sent to the Metering Device to retrieve the log of Top Up codes received by the meter. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: GetTopUpLog + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: GetTopUpLog * @param latestEndTime uint32_t * @param numberOfRecords uint8_t */ -#define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, \ - numberOfRecords) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_GET_TOP_UP_LOG_COMMAND_ID, \ - "wu", \ - latestEndTime, \ - numberOfRecords); - +#define emberAfFillCommandPrepaymentClusterGetTopUpLog(latestEndTime, numberOfRecords) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_TOP_UP_LOG_COMMAND_ID, "wu", latestEndTime, numberOfRecords); /** @brief This command is sent from client to a Prepayment server to set the warning level for low credit. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: SetLowCreditWarningLevel + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: SetLowCreditWarningLevel * @param lowCreditWarningLevel uint32_t */ -#define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, \ - "w", \ - lowCreditWarningLevel); - +#define emberAfFillCommandPrepaymentClusterSetLowCreditWarningLevel(lowCreditWarningLevel) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID, "w", lowCreditWarningLevel); /** @brief This command is used to request the contents of the repayment log. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: GetDebtRepaymentLog + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: GetDebtRepaymentLog * @param latestEndTime uint32_t * @param numberOfDebts uint8_t * @param debtType uint8_t */ -#define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, \ - numberOfDebts, \ - debtType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, \ - "wuu", \ - latestEndTime, \ - numberOfDebts, \ - debtType); - +#define emberAfFillCommandPrepaymentClusterGetDebtRepaymentLog(latestEndTime, numberOfDebts, debtType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID, "wuu", latestEndTime, numberOfDebts, debtType); /** @brief This command is sent from a client to the Prepayment server to set the maximum credit level allowed in the meter. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: SetMaximumCreditLimit + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: SetMaximumCreditLimit * @param providerId uint32_t * @param issuerEventId uint32_t * @param implementationDateTime uint32_t * @param maximumCreditLevel uint32_t * @param maximumCreditPerTopUp uint32_t */ -#define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, \ - issuerEventId, \ - implementationDateTime, \ - maximumCreditLevel, \ - maximumCreditPerTopUp) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, \ - "wwwww", \ - providerId, \ - issuerEventId, \ - implementationDateTime, \ - maximumCreditLevel, \ - maximumCreditPerTopUp); - +#define emberAfFillCommandPrepaymentClusterSetMaximumCreditLimit(providerId, issuerEventId, implementationDateTime, \ + maximumCreditLevel, maximumCreditPerTopUp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID, "wwwww", providerId, issuerEventId, implementationDateTime, \ + maximumCreditLevel, maximumCreditPerTopUp); /** @brief This command is sent from a client to the Prepayment server to set the overall debt cap allowed in the meter. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: SetOverallDebtCap + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: SetOverallDebtCap * @param providerId uint32_t * @param issuerEventId uint32_t * @param implementationDateTime uint32_t * @param overallDebtCap uint32_t */ -#define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, \ - issuerEventId, \ - implementationDateTime, \ - overallDebtCap) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, \ - "wwww", \ - providerId, \ - issuerEventId, \ - implementationDateTime, \ - overallDebtCap); - - -/** @brief This command is generated in response to a GetPrepaySnapshot command. It is used to return a single snapshot to the client. - * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: PublishPrepaySnapshot +#define emberAfFillCommandPrepaymentClusterSetOverallDebtCap(providerId, issuerEventId, implementationDateTime, overallDebtCap) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID, "wwww", providerId, issuerEventId, implementationDateTime, \ + overallDebtCap); + +/** @brief This command is generated in response to a GetPrepaySnapshot command. It is used to return a single snapshot to the + * client. + * + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: PublishPrepaySnapshot * @param snapshotId uint32_t * @param snapshotTime uint32_t * @param totalSnapshotsFound uint8_t @@ -9605,136 +6041,79 @@ * @param snapshotPayload uint8_t* * @param snapshotPayloadLen uint16_t */ -#define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, \ - snapshotTime, \ - totalSnapshotsFound, \ - commandIndex, \ - totalNumberOfCommands, \ - snapshotCause, \ - snapshotPayloadType, \ - snapshotPayload, \ - snapshotPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, \ - "wwuuuwub", \ - snapshotId, \ - snapshotTime, \ - totalSnapshotsFound, \ - commandIndex, \ - totalNumberOfCommands, \ - snapshotCause, \ - snapshotPayloadType, \ - snapshotPayload, \ - snapshotPayloadLen); - +#define emberAfFillCommandPrepaymentClusterPublishPrepaySnapshot(snapshotId, snapshotTime, totalSnapshotsFound, commandIndex, \ + totalNumberOfCommands, snapshotCause, snapshotPayloadType, \ + snapshotPayload, snapshotPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID, "wwuuuwub", snapshotId, snapshotTime, totalSnapshotsFound, \ + commandIndex, totalNumberOfCommands, snapshotCause, snapshotPayloadType, snapshotPayload, \ + snapshotPayloadLen); /** @brief This command is send in response to the ChangePaymentMode Command. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: ChangePaymentModeResponse + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: ChangePaymentModeResponse * @param friendlyCredit uint8_t * @param friendlyCreditCalendarId uint32_t * @param emergencyCreditLimit uint32_t * @param emergencyCreditThreshold uint32_t */ -#define emberAfFillCommandPrepaymentClusterChangePaymentModeResponse(friendlyCredit, \ - friendlyCreditCalendarId, \ - emergencyCreditLimit, \ - emergencyCreditThreshold) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CHANGE_PAYMENT_MODE_RESPONSE_COMMAND_ID, \ - "uwww", \ - friendlyCredit, \ - friendlyCreditCalendarId, \ - emergencyCreditLimit, \ - emergencyCreditThreshold); - +#define emberAfFillCommandPrepaymentClusterChangePaymentModeResponse(friendlyCredit, friendlyCreditCalendarId, \ + emergencyCreditLimit, emergencyCreditThreshold) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CHANGE_PAYMENT_MODE_RESPONSE_COMMAND_ID, "uwww", friendlyCredit, friendlyCreditCalendarId, \ + emergencyCreditLimit, emergencyCreditThreshold); /** @brief This command is send in response to the ConsumerTopUp Command. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: ConsumerTopUpResponse + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: ConsumerTopUpResponse * @param resultType uint8_t * @param topUpValue uint32_t * @param sourceOfTopUp uint8_t * @param creditRemaining uint32_t */ -#define emberAfFillCommandPrepaymentClusterConsumerTopUpResponse(resultType, \ - topUpValue, \ - sourceOfTopUp, \ - creditRemaining) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID, \ - "uwuw", \ - resultType, \ - topUpValue, \ - sourceOfTopUp, \ - creditRemaining); - +#define emberAfFillCommandPrepaymentClusterConsumerTopUpResponse(resultType, topUpValue, sourceOfTopUp, creditRemaining) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID, "uwuw", resultType, topUpValue, sourceOfTopUp, \ + creditRemaining); /** @brief This command is used to send the Top Up Code Log entries to the client. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: PublishTopUpLog + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: PublishTopUpLog * @param commandIndex uint8_t * @param totalNumberOfCommands uint8_t * @param topUpPayload uint8_t* * @param topUpPayloadLen uint16_t */ -#define emberAfFillCommandPrepaymentClusterPublishTopUpLog(commandIndex, \ - totalNumberOfCommands, \ - topUpPayload, \ - topUpPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID, \ - "uub", \ - commandIndex, \ - totalNumberOfCommands, \ - topUpPayload, \ - topUpPayloadLen); - +#define emberAfFillCommandPrepaymentClusterPublishTopUpLog(commandIndex, totalNumberOfCommands, topUpPayload, topUpPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID, "uub", commandIndex, totalNumberOfCommands, topUpPayload, \ + topUpPayloadLen); /** @brief This command is used to send the contents of the Repayment Log. * - * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the HAN. - * Command: PublishDebtLog + * Cluster: Prepayment, The Prepayment Cluster provides the facility to pass messages relating to prepayment between devices on the + * HAN. Command: PublishDebtLog * @param commandIndex uint8_t * @param totalNumberOfCommands uint8_t * @param debtPayload uint8_t* * @param debtPayloadLen uint16_t */ -#define emberAfFillCommandPrepaymentClusterPublishDebtLog(commandIndex, \ - totalNumberOfCommands, \ - debtPayload, \ - debtPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PREPAYMENT_CLUSTER_ID, \ - ZCL_PUBLISH_DEBT_LOG_COMMAND_ID, \ - "uub", \ - commandIndex, \ - totalNumberOfCommands, \ - debtPayload, \ - debtPayloadLen); - +#define emberAfFillCommandPrepaymentClusterPublishDebtLog(commandIndex, totalNumberOfCommands, debtPayload, debtPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PREPAYMENT_CLUSTER_ID, \ + ZCL_PUBLISH_DEBT_LOG_COMMAND_ID, "uub", commandIndex, totalNumberOfCommands, debtPayload, \ + debtPayloadLen); /** @} END Prepayment Commands */ - /** @name Energy Management Commands */ // @{ /** @brief This command is reused from the DRLC cluster. This command is generated in response to the Manage Event command. * - * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring protocols. - * Command: ReportEventStatus + * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring + * protocols. Command: ReportEventStatus * @param issuerEventId uint32_t * @param eventStatus uint8_t * @param eventStatusTime uint32_t @@ -9745,64 +6124,39 @@ * @param dutyCycleApplied uint8_t * @param eventControl uint8_t */ -#define emberAfFillCommandEnergyManagementClusterReportEventStatus(issuerEventId, \ - eventStatus, \ - eventStatusTime, \ - criticalityLevelApplied, \ - coolingTemperatureSetPointApplied, \ - heatingTemperatureSetPointApplied, \ - averageLoadAdjustmentPercentageApplied, \ - dutyCycleApplied, \ - eventControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, \ - ZCL_REPORT_EVENT_STATUS_COMMAND_ID, \ - "wuwuvvuuu", \ - issuerEventId, \ - eventStatus, \ - eventStatusTime, \ - criticalityLevelApplied, \ - coolingTemperatureSetPointApplied, \ - heatingTemperatureSetPointApplied, \ - averageLoadAdjustmentPercentageApplied, \ - dutyCycleApplied, \ - eventControl); - - -/** @brief The Manage Event command allows a remote device (such as an IHD or web portal) to change the behavior of a DRLC cluster client when responding to a DRLC Load Control Event. - * - * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring protocols. - * Command: ManageEvent +#define emberAfFillCommandEnergyManagementClusterReportEventStatus( \ + issuerEventId, eventStatus, eventStatusTime, criticalityLevelApplied, coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, averageLoadAdjustmentPercentageApplied, dutyCycleApplied, eventControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, ZCL_REPORT_EVENT_STATUS_COMMAND_ID, "wuwuvvuuu", issuerEventId, \ + eventStatus, eventStatusTime, criticalityLevelApplied, coolingTemperatureSetPointApplied, \ + heatingTemperatureSetPointApplied, averageLoadAdjustmentPercentageApplied, dutyCycleApplied, \ + eventControl); + +/** @brief The Manage Event command allows a remote device (such as an IHD or web portal) to change the behavior of a DRLC cluster + * client when responding to a DRLC Load Control Event. + * + * Cluster: Energy Management, This cluster provides attributes and commands to assist applications in creating resource monitoring + * protocols. Command: ManageEvent * @param issuerEventId uint32_t * @param deviceClass uint16_t * @param utilityEnrollmentGroup uint8_t * @param actionRequired uint8_t */ -#define emberAfFillCommandEnergyManagementClusterManageEvent(issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - actionRequired) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, \ - ZCL_MANAGE_EVENT_COMMAND_ID, \ - "wvuu", \ - issuerEventId, \ - deviceClass, \ - utilityEnrollmentGroup, \ - actionRequired); - +#define emberAfFillCommandEnergyManagementClusterManageEvent(issuerEventId, deviceClass, utilityEnrollmentGroup, actionRequired) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, ZCL_MANAGE_EVENT_COMMAND_ID, "wvuu", issuerEventId, deviceClass, \ + utilityEnrollmentGroup, actionRequired); /** @} END Energy Management Commands */ - /** @name Calendar Commands */ // @{ -/** @brief The PublishCalendar command is published in response to a GetCalendar command or if new calendar information is available. +/** @brief The PublishCalendar command is published in response to a GetCalendar command or if new calendar information is + * available. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: PublishCalendar + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: PublishCalendar * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerCalendarId uint32_t @@ -9814,37 +6168,18 @@ * @param numberOfWeekProfiles uint8_t * @param numberOfDayProfiles uint8_t */ -#define emberAfFillCommandCalendarClusterPublishCalendar(providerId, \ - issuerEventId, \ - issuerCalendarId, \ - startTime, \ - calendarType, \ - calendarTimeReference, \ - calendarName, \ - numberOfSeasons, \ - numberOfWeekProfiles, \ - numberOfDayProfiles) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_PUBLISH_CALENDAR_COMMAND_ID, \ - "wwwwuusuuu", \ - providerId, \ - issuerEventId, \ - issuerCalendarId, \ - startTime, \ - calendarType, \ - calendarTimeReference, \ - calendarName, \ - numberOfSeasons, \ - numberOfWeekProfiles, \ - numberOfDayProfiles); - +#define emberAfFillCommandCalendarClusterPublishCalendar(providerId, issuerEventId, issuerCalendarId, startTime, calendarType, \ + calendarTimeReference, calendarName, numberOfSeasons, \ + numberOfWeekProfiles, numberOfDayProfiles) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_CALENDAR_COMMAND_ID, "wwwwuusuuu", providerId, issuerEventId, issuerCalendarId, \ + startTime, calendarType, calendarTimeReference, calendarName, numberOfSeasons, numberOfWeekProfiles, \ + numberOfDayProfiles); /** @brief The PublishDayProfile command is published in response to a GetDayProfile command. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: PublishDayProfile + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: PublishDayProfile * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerCalendarId uint32_t @@ -9856,37 +6191,18 @@ * @param dayScheduleEntries uint8_t* * @param dayScheduleEntriesLen uint16_t */ -#define emberAfFillCommandCalendarClusterPublishDayProfile(providerId, \ - issuerEventId, \ - issuerCalendarId, \ - dayId, \ - totalNumberOfScheduleEntries, \ - commandIndex, \ - totalNumberOfCommands, \ - calendarType, \ - dayScheduleEntries, \ - dayScheduleEntriesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, \ - "wwwuuuuub", \ - providerId, \ - issuerEventId, \ - issuerCalendarId, \ - dayId, \ - totalNumberOfScheduleEntries, \ - commandIndex, \ - totalNumberOfCommands, \ - calendarType, \ - dayScheduleEntries, \ - dayScheduleEntriesLen); - +#define emberAfFillCommandCalendarClusterPublishDayProfile(providerId, issuerEventId, issuerCalendarId, dayId, \ + totalNumberOfScheduleEntries, commandIndex, totalNumberOfCommands, \ + calendarType, dayScheduleEntries, dayScheduleEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID, "wwwuuuuub", providerId, issuerEventId, issuerCalendarId, dayId, \ + totalNumberOfScheduleEntries, commandIndex, totalNumberOfCommands, calendarType, dayScheduleEntries, \ + dayScheduleEntriesLen); /** @brief The PublishWeekProfile command is published in response to a GetWeekProfile command. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: PublishWeekProfile + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: PublishWeekProfile * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerCalendarId uint32_t @@ -9899,39 +6215,18 @@ * @param dayIdRefSaturday uint8_t * @param dayIdRefSunday uint8_t */ -#define emberAfFillCommandCalendarClusterPublishWeekProfile(providerId, \ - issuerEventId, \ - issuerCalendarId, \ - weekId, \ - dayIdRefMonday, \ - dayIdRefTuesday, \ - dayIdRefWednesday, \ - dayIdRefThursday, \ - dayIdRefFriday, \ - dayIdRefSaturday, \ - dayIdRefSunday) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, \ - "wwwuuuuuuuu", \ - providerId, \ - issuerEventId, \ - issuerCalendarId, \ - weekId, \ - dayIdRefMonday, \ - dayIdRefTuesday, \ - dayIdRefWednesday, \ - dayIdRefThursday, \ - dayIdRefFriday, \ - dayIdRefSaturday, \ - dayIdRefSunday); - +#define emberAfFillCommandCalendarClusterPublishWeekProfile(providerId, issuerEventId, issuerCalendarId, weekId, dayIdRefMonday, \ + dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, \ + dayIdRefSaturday, dayIdRefSunday) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID, "wwwuuuuuuuu", providerId, issuerEventId, issuerCalendarId, \ + weekId, dayIdRefMonday, dayIdRefTuesday, dayIdRefWednesday, dayIdRefThursday, dayIdRefFriday, \ + dayIdRefSaturday, dayIdRefSunday); /** @brief The PublishSeasons command is published in response to a GetSeason command. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: PublishSeasons + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: PublishSeasons * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerCalendarId uint32_t @@ -9940,31 +6235,16 @@ * @param seasonEntries uint8_t* * @param seasonEntriesLen uint16_t */ -#define emberAfFillCommandCalendarClusterPublishSeasons(providerId, \ - issuerEventId, \ - issuerCalendarId, \ - commandIndex, \ - totalNumberOfCommands, \ - seasonEntries, \ - seasonEntriesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_PUBLISH_SEASONS_COMMAND_ID, \ - "wwwuub", \ - providerId, \ - issuerEventId, \ - issuerCalendarId, \ - commandIndex, \ - totalNumberOfCommands, \ - seasonEntries, \ - seasonEntriesLen); - +#define emberAfFillCommandCalendarClusterPublishSeasons(providerId, issuerEventId, issuerCalendarId, commandIndex, \ + totalNumberOfCommands, seasonEntries, seasonEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_SEASONS_COMMAND_ID, "wwwuub", providerId, issuerEventId, issuerCalendarId, commandIndex, \ + totalNumberOfCommands, seasonEntries, seasonEntriesLen); /** @brief The PublishSpecialDays command is published in response to a GetSpecialDays command or if a calendar update is available. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: PublishSpecialDays + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: PublishSpecialDays * @param providerId uint32_t * @param issuerEventId uint32_t * @param issuerCalendarId uint32_t @@ -9976,314 +6256,188 @@ * @param specialDayEntries uint8_t* * @param specialDayEntriesLen uint16_t */ -#define emberAfFillCommandCalendarClusterPublishSpecialDays(providerId, \ - issuerEventId, \ - issuerCalendarId, \ - startTime, \ - calendarType, \ - totalNumberOfSpecialDays, \ - commandIndex, \ - totalNumberOfCommands, \ - specialDayEntries, \ - specialDayEntriesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, \ - "wwwwuuuub", \ - providerId, \ - issuerEventId, \ - issuerCalendarId, \ - startTime, \ - calendarType, \ - totalNumberOfSpecialDays, \ - commandIndex, \ - totalNumberOfCommands, \ - specialDayEntries, \ - specialDayEntriesLen); - +#define emberAfFillCommandCalendarClusterPublishSpecialDays(providerId, issuerEventId, issuerCalendarId, startTime, calendarType, \ + totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, \ + specialDayEntries, specialDayEntriesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID, "wwwwuuuub", providerId, issuerEventId, issuerCalendarId, \ + startTime, calendarType, totalNumberOfSpecialDays, commandIndex, totalNumberOfCommands, \ + specialDayEntries, specialDayEntriesLen); /** @brief The CancelCalendar command indicates that all data associated with a particular calendar instance should be discarded. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: CancelCalendar + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: CancelCalendar * @param providerId uint32_t * @param issuerCalendarId uint32_t * @param calendarType uint8_t */ -#define emberAfFillCommandCalendarClusterCancelCalendar(providerId, \ - issuerCalendarId, \ - calendarType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_CANCEL_CALENDAR_COMMAND_ID, \ - "wwu", \ - providerId, \ - issuerCalendarId, \ - calendarType); - +#define emberAfFillCommandCalendarClusterCancelCalendar(providerId, issuerCalendarId, calendarType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_CANCEL_CALENDAR_COMMAND_ID, "wwu", providerId, issuerCalendarId, calendarType); /** @brief This command initiates PublishCalendar command(s) for scheduled Calendar updates. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetCalendar + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetCalendar * @param earliestStartTime uint32_t * @param minIssuerEventId uint32_t * @param numberOfCalendars uint8_t * @param calendarType uint8_t * @param providerId uint32_t */ -#define emberAfFillCommandCalendarClusterGetCalendar(earliestStartTime, \ - minIssuerEventId, \ - numberOfCalendars, \ - calendarType, \ - providerId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_CALENDAR_COMMAND_ID, \ - "wwuuw", \ - earliestStartTime, \ - minIssuerEventId, \ - numberOfCalendars, \ - calendarType, \ - providerId); - +#define emberAfFillCommandCalendarClusterGetCalendar(earliestStartTime, minIssuerEventId, numberOfCalendars, calendarType, \ + providerId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_CALENDAR_COMMAND_ID, "wwuuw", earliestStartTime, minIssuerEventId, numberOfCalendars, \ + calendarType, providerId); /** @brief This command initiates one or more PublishDayProfile commands for the referenced Calendar. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetDayProfiles + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetDayProfiles * @param providerId uint32_t * @param issuerCalendarId uint32_t * @param startDayId uint8_t * @param numberOfDays uint8_t */ -#define emberAfFillCommandCalendarClusterGetDayProfiles(providerId, \ - issuerCalendarId, \ - startDayId, \ - numberOfDays) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_DAY_PROFILES_COMMAND_ID, \ - "wwuu", \ - providerId, \ - issuerCalendarId, \ - startDayId, \ - numberOfDays); - +#define emberAfFillCommandCalendarClusterGetDayProfiles(providerId, issuerCalendarId, startDayId, numberOfDays) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_DAY_PROFILES_COMMAND_ID, "wwuu", providerId, issuerCalendarId, startDayId, numberOfDays); /** @brief This command initiates one or more PublishWeekProfile commands for the referenced Calendar. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetWeekProfiles + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetWeekProfiles * @param providerId uint32_t * @param issuerCalendarId uint32_t * @param startWeekId uint8_t * @param numberOfWeeks uint8_t */ -#define emberAfFillCommandCalendarClusterGetWeekProfiles(providerId, \ - issuerCalendarId, \ - startWeekId, \ - numberOfWeeks) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_WEEK_PROFILES_COMMAND_ID, \ - "wwuu", \ - providerId, \ - issuerCalendarId, \ - startWeekId, \ - numberOfWeeks); - +#define emberAfFillCommandCalendarClusterGetWeekProfiles(providerId, issuerCalendarId, startWeekId, numberOfWeeks) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_WEEK_PROFILES_COMMAND_ID, "wwuu", providerId, issuerCalendarId, startWeekId, numberOfWeeks); /** @brief This command initiates one or more PublishSeasons commands for the referenced Calendar. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetSeasons + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetSeasons * @param providerId uint32_t * @param issuerCalendarId uint32_t */ -#define emberAfFillCommandCalendarClusterGetSeasons(providerId, \ - issuerCalendarId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_SEASONS_COMMAND_ID, \ - "ww", \ - providerId, \ - issuerCalendarId); - +#define emberAfFillCommandCalendarClusterGetSeasons(providerId, issuerCalendarId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_SEASONS_COMMAND_ID, "ww", providerId, issuerCalendarId); /** @brief This command initiates one or more PublishSpecialDays commands for the scheduled Special Day Table updates. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetSpecialDays + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetSpecialDays * @param startTime uint32_t * @param numberOfEvents uint8_t * @param calendarType uint8_t * @param providerId uint32_t * @param issuerCalendarId uint32_t */ -#define emberAfFillCommandCalendarClusterGetSpecialDays(startTime, \ - numberOfEvents, \ - calendarType, \ - providerId, \ - issuerCalendarId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_SPECIAL_DAYS_COMMAND_ID, \ - "wuuww", \ - startTime, \ - numberOfEvents, \ - calendarType, \ - providerId, \ - issuerCalendarId); - +#define emberAfFillCommandCalendarClusterGetSpecialDays(startTime, numberOfEvents, calendarType, providerId, issuerCalendarId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_SPECIAL_DAYS_COMMAND_ID, "wuuww", startTime, numberOfEvents, calendarType, providerId, \ + issuerCalendarId); /** @brief This command initiates the return of the last CancelCalendar command held on the associated server. * - * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based protocol. - * Command: GetCalendarCancellation + * Cluster: Calendar, This cluster provides attributes and commands to assist applications in developing time and date based + * protocol. Command: GetCalendarCancellation */ -#define emberAfFillCommandCalendarClusterGetCalendarCancellation() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CALENDAR_CLUSTER_ID, \ - ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandCalendarClusterGetCalendarCancellation() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CALENDAR_CLUSTER_ID, \ + ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID, ""); /** @} END Calendar Commands */ - /** @name Device Management Commands */ // @{ /** @brief This command is used to request the ESI to respond with information regarding any available change of tenancy. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: GetChangeOfTenancy + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: GetChangeOfTenancy */ -#define emberAfFillCommandDeviceManagementClusterGetChangeOfTenancy() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDeviceManagementClusterGetChangeOfTenancy() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID, ""); /** @brief This command is used to request the ESI to respond with information regarding any available change of supplier. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: GetChangeOfSupplier + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: GetChangeOfSupplier */ -#define emberAfFillCommandDeviceManagementClusterGetChangeOfSupplier() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDeviceManagementClusterGetChangeOfSupplier() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID, ""); /** @brief This command is used to request the current password from the server. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: RequestNewPassword + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: RequestNewPassword * @param passwordType uint8_t */ -#define emberAfFillCommandDeviceManagementClusterRequestNewPassword(passwordType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, \ - "u", \ - passwordType); - +#define emberAfFillCommandDeviceManagementClusterRequestNewPassword(passwordType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID, "u", passwordType); /** @brief This command is used to request the ESI to respond with information regarding any pending change of Site ID. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: GetSiteId + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: GetSiteId */ -#define emberAfFillCommandDeviceManagementClusterGetSiteId() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_GET_SITE_ID_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDeviceManagementClusterGetSiteId() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_GET_SITE_ID_COMMAND_ID, ""); /** @brief This command is sent in response to a GetEventConfiguration command. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: ReportEventConfiguration + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: ReportEventConfiguration * @param commandIndex uint8_t * @param totalCommands uint8_t * @param eventConfigurationPayload uint8_t* * @param eventConfigurationPayloadLen uint16_t */ -#define emberAfFillCommandDeviceManagementClusterReportEventConfiguration(commandIndex, \ - totalCommands, \ - eventConfigurationPayload, \ - eventConfigurationPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, \ - "uub", \ - commandIndex, \ - totalCommands, \ - eventConfigurationPayload, \ - eventConfigurationPayloadLen); - +#define emberAfFillCommandDeviceManagementClusterReportEventConfiguration(commandIndex, totalCommands, eventConfigurationPayload, \ + eventConfigurationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID, "uub", commandIndex, \ + totalCommands, eventConfigurationPayload, eventConfigurationPayloadLen); /** @brief This command is used to request the ESI to respond with information regarding any pending change of Customer ID Number. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: GetCIN + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: GetCIN */ -#define emberAfFillCommandDeviceManagementClusterGetCIN() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_GET_C_I_N_COMMAND_ID, \ - ""); - +#define emberAfFillCommandDeviceManagementClusterGetCIN() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_GET_C_I_N_COMMAND_ID, ""); /** @brief This command is used to change the tenancy of a meter. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: PublishChangeOfTenancy + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: PublishChangeOfTenancy * @param providerId uint32_t * @param issuerEventId uint32_t * @param tariffType uint8_t * @param implementationDateTime uint32_t * @param proposedTenancyChangeControl uint32_t */ -#define emberAfFillCommandDeviceManagementClusterPublishChangeOfTenancy(providerId, \ - issuerEventId, \ - tariffType, \ - implementationDateTime, \ - proposedTenancyChangeControl) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID, \ - "wwuww", \ - providerId, \ - issuerEventId, \ - tariffType, \ - implementationDateTime, \ - proposedTenancyChangeControl); - +#define emberAfFillCommandDeviceManagementClusterPublishChangeOfTenancy(providerId, issuerEventId, tariffType, \ + implementationDateTime, proposedTenancyChangeControl) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID, "wwuww", providerId, \ + issuerEventId, tariffType, implementationDateTime, proposedTenancyChangeControl); /** @brief This command is used to change the Supplier (energy supplier) that is supplying the meter (s). * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: PublishChangeOfSupplier + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: PublishChangeOfSupplier * @param currentProviderId uint32_t * @param issuerEventId uint32_t * @param tariffType uint8_t @@ -10293,84 +6447,48 @@ * @param proposedProviderName uint8_t* * @param proposedProviderContactDetails uint8_t* */ -#define emberAfFillCommandDeviceManagementClusterPublishChangeOfSupplier(currentProviderId, \ - issuerEventId, \ - tariffType, \ - proposedProviderId, \ - providerChangeImplementationTime, \ - providerChangeControl, \ - proposedProviderName, \ - proposedProviderContactDetails) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID, \ - "wwuwwwss", \ - currentProviderId, \ - issuerEventId, \ - tariffType, \ - proposedProviderId, \ - providerChangeImplementationTime, \ - providerChangeControl, \ - proposedProviderName, \ - proposedProviderContactDetails); - +#define emberAfFillCommandDeviceManagementClusterPublishChangeOfSupplier( \ + currentProviderId, issuerEventId, tariffType, proposedProviderId, providerChangeImplementationTime, providerChangeControl, \ + proposedProviderName, proposedProviderContactDetails) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID, "wwuwwwss", \ + currentProviderId, issuerEventId, tariffType, proposedProviderId, providerChangeImplementationTime, \ + providerChangeControl, proposedProviderName, proposedProviderContactDetails); /** @brief This command is used to send the current password to the client. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: RequestNewPasswordResponse + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: RequestNewPasswordResponse * @param issuerEventId uint32_t * @param implementationDateTime uint32_t * @param durationInMinutes uint16_t * @param passwordType uint8_t * @param password uint8_t* */ -#define emberAfFillCommandDeviceManagementClusterRequestNewPasswordResponse(issuerEventId, \ - implementationDateTime, \ - durationInMinutes, \ - passwordType, \ - password) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_REQUEST_NEW_PASSWORD_RESPONSE_COMMAND_ID, \ - "wwvus", \ - issuerEventId, \ - implementationDateTime, \ - durationInMinutes, \ - passwordType, \ - password); - +#define emberAfFillCommandDeviceManagementClusterRequestNewPasswordResponse(issuerEventId, implementationDateTime, \ + durationInMinutes, passwordType, password) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_REQUEST_NEW_PASSWORD_RESPONSE_COMMAND_ID, "wwvus", \ + issuerEventId, implementationDateTime, durationInMinutes, passwordType, password); /** @brief This command is used to set the siteID. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: UpdateSiteId + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: UpdateSiteId * @param issuerEventId uint32_t * @param siteIdTime uint32_t * @param providerId uint32_t * @param siteId uint8_t* */ -#define emberAfFillCommandDeviceManagementClusterUpdateSiteId(issuerEventId, \ - siteIdTime, \ - providerId, \ - siteId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_UPDATE_SITE_ID_COMMAND_ID, \ - "wwws", \ - issuerEventId, \ - siteIdTime, \ - providerId, \ - siteId); - +#define emberAfFillCommandDeviceManagementClusterUpdateSiteId(issuerEventId, siteIdTime, providerId, siteId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_UPDATE_SITE_ID_COMMAND_ID, "wwws", issuerEventId, siteIdTime, \ + providerId, siteId); /** @brief This command provides a method to set the event configuration attributes, held in a client device. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: SetEventConfiguration + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: SetEventConfiguration * @param issuerEventId uint32_t * @param startDateTime uint32_t * @param eventConfiguration uint8_t @@ -10378,70 +6496,44 @@ * @param eventConfigurationPayload uint8_t* * @param eventConfigurationPayloadLen uint16_t */ -#define emberAfFillCommandDeviceManagementClusterSetEventConfiguration(issuerEventId, \ - startDateTime, \ - eventConfiguration, \ - configurationControl, \ - eventConfigurationPayload, \ - eventConfigurationPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID, \ - "wwuub", \ - issuerEventId, \ - startDateTime, \ - eventConfiguration, \ - configurationControl, \ - eventConfigurationPayload, \ - eventConfigurationPayloadLen); - +#define emberAfFillCommandDeviceManagementClusterSetEventConfiguration(issuerEventId, startDateTime, eventConfiguration, \ + configurationControl, eventConfigurationPayload, \ + eventConfigurationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID, "wwuub", issuerEventId, \ + startDateTime, eventConfiguration, configurationControl, eventConfigurationPayload, \ + eventConfigurationPayloadLen); /** @brief This command allows the server to request details of event configurations. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: GetEventConfiguration + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: GetEventConfiguration * @param eventId uint16_t */ -#define emberAfFillCommandDeviceManagementClusterGetEventConfiguration(eventId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID, \ - "v", \ - eventId); - +#define emberAfFillCommandDeviceManagementClusterGetEventConfiguration(eventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID, "v", eventId); /** @brief This command is used to set the CustomerIDNumber attribute held in the Metering cluster. * - * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer protocols. - * Command: UpdateCIN + * Cluster: Device Management, This cluster provides attributes and commands to support device-cognisant application layer + * protocols. Command: UpdateCIN * @param issuerEventId uint32_t * @param implementationTime uint32_t * @param providerId uint32_t * @param customerIdNumber uint8_t* */ -#define emberAfFillCommandDeviceManagementClusterUpdateCIN(issuerEventId, \ - implementationTime, \ - providerId, \ - customerIdNumber) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, \ - ZCL_UPDATE_C_I_N_COMMAND_ID, \ - "wwws", \ - issuerEventId, \ - implementationTime, \ - providerId, \ - customerIdNumber); - +#define emberAfFillCommandDeviceManagementClusterUpdateCIN(issuerEventId, implementationTime, providerId, customerIdNumber) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, ZCL_UPDATE_C_I_N_COMMAND_ID, "wwws", issuerEventId, \ + implementationTime, providerId, customerIdNumber); /** @} END Device Management Commands */ - /** @name Events Commands */ // @{ -/** @brief The GetEventLog command allows a client to request events from a server's event logs. One or more PublishEventLog commands are returned on receipt of this command. +/** @brief The GetEventLog command allows a client to request events from a server's event logs. One or more PublishEventLog + * commands are returned on receipt of this command. * * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. * Command: GetEventLog @@ -10452,24 +6544,10 @@ * @param numberOfEvents uint8_t * @param eventOffset uint16_t */ -#define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, \ - eventId, \ - startTime, \ - endTime, \ - numberOfEvents, \ - eventOffset) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_EVENTS_CLUSTER_ID, \ - ZCL_GET_EVENT_LOG_COMMAND_ID, \ - "uvwwuv", \ - eventControlLogId, \ - eventId, \ - startTime, \ - endTime, \ - numberOfEvents, \ - eventOffset); - +#define emberAfFillCommandEventsClusterGetEventLog(eventControlLogId, eventId, startTime, endTime, numberOfEvents, eventOffset) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_EVENTS_CLUSTER_ID, \ + ZCL_GET_EVENT_LOG_COMMAND_ID, "uvwwuv", eventControlLogId, eventId, startTime, endTime, \ + numberOfEvents, eventOffset); /** @brief The ClearEventLogRequest command requests that an Events server device clear the specified event log(s). * @@ -10477,16 +6555,12 @@ * Command: ClearEventLogRequest * @param logId uint8_t */ -#define emberAfFillCommandEventsClusterClearEventLogRequest(logId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_EVENTS_CLUSTER_ID, \ - ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, \ - "u", \ - logId); - +#define emberAfFillCommandEventsClusterClearEventLogRequest(logId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_EVENTS_CLUSTER_ID, \ + ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID, "u", logId); -/** @brief The PublishEvent command is generated upon an event trigger from within the reporting device and, if supported, the associated Event Configuration attribute in the Device Management cluster. +/** @brief The PublishEvent command is generated upon an event trigger from within the reporting device and, if supported, the + * associated Event Configuration attribute in the Device Management cluster. * * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. * Command: PublishEvent @@ -10496,24 +6570,12 @@ * @param eventControl uint8_t * @param eventData uint8_t* */ -#define emberAfFillCommandEventsClusterPublishEvent(logId, \ - eventId, \ - eventTime, \ - eventControl, \ - eventData) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_EVENTS_CLUSTER_ID, \ - ZCL_PUBLISH_EVENT_COMMAND_ID, \ - "uvwus", \ - logId, \ - eventId, \ - eventTime, \ - eventControl, \ - eventData); - - -/** @brief This command is generated on receipt of a GetEventLog command. The command returns the most recent event first and up to the number of events requested. +#define emberAfFillCommandEventsClusterPublishEvent(logId, eventId, eventTime, eventControl, eventData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_EVENTS_CLUSTER_ID, \ + ZCL_PUBLISH_EVENT_COMMAND_ID, "uvwus", logId, eventId, eventTime, eventControl, eventData); + +/** @brief This command is generated on receipt of a GetEventLog command. The command returns the most recent event first and up to + * the number of events requested. * * Cluster: Events, This cluster provides an interface on which applications can use event-based protocols. * Command: PublishEventLog @@ -10524,24 +6586,11 @@ * @param logPayload uint8_t* * @param logPayloadLen uint16_t */ -#define emberAfFillCommandEventsClusterPublishEventLog(totalNumberOfEvents, \ - commandIndex, \ - totalCommands, \ - logPayloadControl, \ - logPayload, \ - logPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_EVENTS_CLUSTER_ID, \ - ZCL_PUBLISH_EVENT_LOG_COMMAND_ID, \ - "vuuub", \ - totalNumberOfEvents, \ - commandIndex, \ - totalCommands, \ - logPayloadControl, \ - logPayload, \ - logPayloadLen); - +#define emberAfFillCommandEventsClusterPublishEventLog(totalNumberOfEvents, commandIndex, totalCommands, logPayloadControl, \ + logPayload, logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_EVENTS_CLUSTER_ID, \ + ZCL_PUBLISH_EVENT_LOG_COMMAND_ID, "vuuub", totalNumberOfEvents, commandIndex, totalCommands, \ + logPayloadControl, logPayload, logPayloadLen); /** @brief This command is generated on receipt of a Clear Event Log Request command. * @@ -10549,21 +6598,16 @@ * Command: ClearEventLogResponse * @param clearedEventsLogs uint8_t */ -#define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_EVENTS_CLUSTER_ID, \ - ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, \ - "u", \ - clearedEventsLogs); - +#define emberAfFillCommandEventsClusterClearEventLogResponse(clearedEventsLogs) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_EVENTS_CLUSTER_ID, \ + ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID, "u", clearedEventsLogs); /** @} END Events Commands */ - /** @name MDU Pairing Commands */ // @{ -/** @brief The Pairing Response command provides a device joining a MDU network with a list of the devices that will constitute the 'virtual HAN' for the household in which the joining device is to operate. +/** @brief The Pairing Response command provides a device joining a MDU network with a list of the devices that will constitute the + * 'virtual HAN' for the household in which the joining device is to operate. * * Cluster: MDU Pairing, This cluster seeks to assist in the commissioning of networks that include multi-dwelling units (MDUs). * Command: PairingResponse @@ -10574,46 +6618,26 @@ * @param eui64s uint8_t* * @param eui64sLen uint16_t */ -#define emberAfFillCommandMduPairingClusterPairingResponse(pairingInformationVersion, \ - totalNumberOfDevices, \ - commandIndex, \ - totalNumberOfCommands, \ - eui64s, \ - eui64sLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_MDU_PAIRING_CLUSTER_ID, \ - ZCL_PAIRING_RESPONSE_COMMAND_ID, \ - "wuuub", \ - pairingInformationVersion, \ - totalNumberOfDevices, \ - commandIndex, \ - totalNumberOfCommands, \ - eui64s, \ - eui64sLen); - - -/** @brief The Pairing Request command allows a device joining a MDU network to determine the devices that will constitute the 'virtual HAN' for the household in which it is to operate. +#define emberAfFillCommandMduPairingClusterPairingResponse(pairingInformationVersion, totalNumberOfDevices, commandIndex, \ + totalNumberOfCommands, eui64s, eui64sLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_MDU_PAIRING_CLUSTER_ID, \ + ZCL_PAIRING_RESPONSE_COMMAND_ID, "wuuub", pairingInformationVersion, totalNumberOfDevices, \ + commandIndex, totalNumberOfCommands, eui64s, eui64sLen); + +/** @brief The Pairing Request command allows a device joining a MDU network to determine the devices that will constitute the + * 'virtual HAN' for the household in which it is to operate. * * Cluster: MDU Pairing, This cluster seeks to assist in the commissioning of networks that include multi-dwelling units (MDUs). * Command: PairingRequest * @param localPairingInformationVersion uint32_t * @param eui64OfRequestingDevice uint8_t* */ -#define emberAfFillCommandMduPairingClusterPairingRequest(localPairingInformationVersion, \ - eui64OfRequestingDevice) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MDU_PAIRING_CLUSTER_ID, \ - ZCL_PAIRING_REQUEST_COMMAND_ID, \ - "w8", \ - localPairingInformationVersion, \ - eui64OfRequestingDevice); - +#define emberAfFillCommandMduPairingClusterPairingRequest(localPairingInformationVersion, eui64OfRequestingDevice) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_MDU_PAIRING_CLUSTER_ID, \ + ZCL_PAIRING_REQUEST_COMMAND_ID, "w8", localPairingInformationVersion, eui64OfRequestingDevice); /** @} END MDU Pairing Commands */ - /** @name Sub-GHz Commands */ // @{ /** @brief The server sends it to temporarily suspend ZCL messages from clients it identifies as causing too much traffic. @@ -10622,31 +6646,21 @@ * Command: SuspendZclMessages * @param period uint8_t */ -#define emberAfFillCommandSubGhzClusterSuspendZclMessages(period) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SUB_GHZ_CLUSTER_ID, \ - ZCL_SUSPEND_ZCL_MESSAGES_COMMAND_ID, \ - "u", \ - period); - +#define emberAfFillCommandSubGhzClusterSuspendZclMessages(period) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_SUB_GHZ_CLUSTER_ID, \ + ZCL_SUSPEND_ZCL_MESSAGES_COMMAND_ID, "u", period); /** @brief The client sends it to determine the current status of its ZCL communications from the server. * * Cluster: Sub-GHz, Used by the Smart Energy profile for duty cycle monitoring and frequency agility. * Command: GetSuspendZclMessagesStatus */ -#define emberAfFillCommandSubGhzClusterGetSuspendZclMessagesStatus() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SUB_GHZ_CLUSTER_ID, \ - ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSubGhzClusterGetSuspendZclMessagesStatus() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_SUB_GHZ_CLUSTER_ID, \ + ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID, ""); /** @} END Sub-GHz Commands */ - /** @name Key Establishment Commands */ // @{ /** @brief Command description for InitiateKeyEstablishmentRequest @@ -10658,21 +6672,11 @@ * @param confirmKeyGenerateTime uint8_t * @param identity uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, \ - ephemeralDataGenerateTime, \ - confirmKeyGenerateTime, \ - identity) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, \ - "vuub", \ - keyEstablishmentSuite, \ - ephemeralDataGenerateTime, \ - confirmKeyGenerateTime, \ - identity, \ - 48); - +#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentRequest(keyEstablishmentSuite, ephemeralDataGenerateTime, \ + confirmKeyGenerateTime, identity) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID, "vuub", \ + keyEstablishmentSuite, ephemeralDataGenerateTime, confirmKeyGenerateTime, identity, 48); /** @brief Command description for EphemeralDataRequest * @@ -10680,15 +6684,9 @@ * Command: EphemeralDataRequest * @param ephemeralData uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataRequest(ephemeralData) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, \ - "b", \ - ephemeralData, \ - 22); - +#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataRequest(ephemeralData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID, "b", ephemeralData, 22); /** @brief Command description for ConfirmKeyDataRequest * @@ -10696,14 +6694,10 @@ * Command: ConfirmKeyDataRequest * @param secureMessageAuthenticationCode uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, \ - "G", \ - secureMessageAuthenticationCode); - +#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataRequest(secureMessageAuthenticationCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID, "G", \ + secureMessageAuthenticationCode); /** @brief Command description for TerminateKeyEstablishment * @@ -10713,18 +6707,11 @@ * @param waitTime uint8_t * @param keyEstablishmentSuite uint16_t */ -#define emberAfFillCommandKeyEstablishmentClusterServerToClientTerminateKeyEstablishment(statusCode, \ - waitTime, \ - keyEstablishmentSuite) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, \ - "uuv", \ - statusCode, \ - waitTime, \ - keyEstablishmentSuite); - +#define emberAfFillCommandKeyEstablishmentClusterServerToClientTerminateKeyEstablishment(statusCode, waitTime, \ + keyEstablishmentSuite) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, "uuv", statusCode, \ + waitTime, keyEstablishmentSuite); /** @brief Command description for TerminateKeyEstablishment * @@ -10734,18 +6721,11 @@ * @param waitTime uint8_t * @param keyEstablishmentSuite uint16_t */ -#define emberAfFillCommandKeyEstablishmentClusterClientToServerTerminateKeyEstablishment(statusCode, \ - waitTime, \ - keyEstablishmentSuite) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, \ - "uuv", \ - statusCode, \ - waitTime, \ - keyEstablishmentSuite); - +#define emberAfFillCommandKeyEstablishmentClusterClientToServerTerminateKeyEstablishment(statusCode, waitTime, \ + keyEstablishmentSuite) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID, "uuv", statusCode, \ + waitTime, keyEstablishmentSuite); /** @brief Command description for InitiateKeyEstablishmentResponse * @@ -10756,21 +6736,11 @@ * @param confirmKeyGenerateTime uint8_t * @param identity uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentResponse(requestedKeyEstablishmentSuite, \ - ephemeralDataGenerateTime, \ - confirmKeyGenerateTime, \ - identity) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_INITIATE_KEY_ESTABLISHMENT_RESPONSE_COMMAND_ID, \ - "vuub", \ - requestedKeyEstablishmentSuite, \ - ephemeralDataGenerateTime, \ - confirmKeyGenerateTime, \ - identity, \ - 48); - +#define emberAfFillCommandKeyEstablishmentClusterInitiateKeyEstablishmentResponse( \ + requestedKeyEstablishmentSuite, ephemeralDataGenerateTime, confirmKeyGenerateTime, identity) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_INITIATE_KEY_ESTABLISHMENT_RESPONSE_COMMAND_ID, "vuub", \ + requestedKeyEstablishmentSuite, ephemeralDataGenerateTime, confirmKeyGenerateTime, identity, 48); /** @brief Command description for EphemeralDataResponse * @@ -10778,15 +6748,9 @@ * Command: EphemeralDataResponse * @param ephemeralData uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataResponse(ephemeralData) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID, \ - "b", \ - ephemeralData, \ - 22); - +#define emberAfFillCommandKeyEstablishmentClusterEphemeralDataResponse(ephemeralData) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID, "b", ephemeralData, 22); /** @brief Command description for ConfirmKeyDataResponse * @@ -10794,18 +6758,13 @@ * Command: ConfirmKeyDataResponse * @param secureMessageAuthenticationCode uint8_t* */ -#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataResponse(secureMessageAuthenticationCode) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, \ - ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID, \ - "G", \ - secureMessageAuthenticationCode); - +#define emberAfFillCommandKeyEstablishmentClusterConfirmKeyDataResponse(secureMessageAuthenticationCode) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID, "G", \ + secureMessageAuthenticationCode); /** @} END Key Establishment Commands */ - /** @name Information Commands */ // @{ /** @brief Command description for RequestInformation @@ -10817,20 +6776,11 @@ * @param requestInformationPayload uint8_t* * @param requestInformationPayloadLen uint16_t */ -#define emberAfFillCommandInformationClusterRequestInformation(inquiryId, \ - dataTypeId, \ - requestInformationPayload, \ - requestInformationPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_REQUEST_INFORMATION_COMMAND_ID, \ - "uub", \ - inquiryId, \ - dataTypeId, \ - requestInformationPayload, \ - requestInformationPayloadLen); - +#define emberAfFillCommandInformationClusterRequestInformation(inquiryId, dataTypeId, requestInformationPayload, \ + requestInformationPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_INFORMATION_COMMAND_ID, "uub", inquiryId, dataTypeId, requestInformationPayload, \ + requestInformationPayloadLen); /** @brief Command description for PushInformationResponse * @@ -10839,16 +6789,9 @@ * @param notificationList uint8_t* * @param notificationListLen uint16_t */ -#define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, \ - notificationListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, \ - "b", \ - notificationList, \ - notificationListLen); - +#define emberAfFillCommandInformationClusterPushInformationResponse(notificationList, notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID, "b", notificationList, notificationListLen); /** @brief Command description for SendPreference * @@ -10858,18 +6801,9 @@ * @param preferencePayload uint8_t* * @param preferencePayloadLen uint16_t */ -#define emberAfFillCommandInformationClusterSendPreference(preferenceType, \ - preferencePayload, \ - preferencePayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_SEND_PREFERENCE_COMMAND_ID, \ - "vb", \ - preferenceType, \ - preferencePayload, \ - preferencePayloadLen); - +#define emberAfFillCommandInformationClusterSendPreference(preferenceType, preferencePayload, preferencePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SEND_PREFERENCE_COMMAND_ID, "vb", preferenceType, preferencePayload, preferencePayloadLen); /** @brief Command description for RequestPreferenceResponse * @@ -10880,20 +6814,11 @@ * @param preferencePayload uint8_t* * @param preferencePayloadLen uint16_t */ -#define emberAfFillCommandInformationClusterRequestPreferenceResponse(statusFeedback, \ - preferenceType, \ - preferencePayload, \ - preferencePayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID, \ - "uvb", \ - statusFeedback, \ - preferenceType, \ - preferencePayload, \ - preferencePayloadLen); - +#define emberAfFillCommandInformationClusterRequestPreferenceResponse(statusFeedback, preferenceType, preferencePayload, \ + preferencePayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID, "uvb", statusFeedback, preferenceType, \ + preferencePayload, preferencePayloadLen); /** @brief Command description for Update * @@ -10904,20 +6829,9 @@ * @param contents uint8_t* * @param contentsLen uint16_t */ -#define emberAfFillCommandInformationClusterUpdate(accessControl, \ - option, \ - contents, \ - contentsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_UPDATE_COMMAND_ID, \ - "uub", \ - accessControl, \ - option, \ - contents, \ - contentsLen); - +#define emberAfFillCommandInformationClusterUpdate(accessControl, option, contents, contentsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_UPDATE_COMMAND_ID, "uub", accessControl, option, contents, contentsLen); /** @brief Command description for Delete * @@ -10927,18 +6841,9 @@ * @param contentIds uint8_t* * @param contentIdsLen uint16_t */ -#define emberAfFillCommandInformationClusterDelete(deletionOptions, \ - contentIds, \ - contentIdsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_DELETE_COMMAND_ID, \ - "ub", \ - deletionOptions, \ - contentIds, \ - contentIdsLen); - +#define emberAfFillCommandInformationClusterDelete(deletionOptions, contentIds, contentIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_DELETE_COMMAND_ID, "ub", deletionOptions, contentIds, contentIdsLen); /** @brief Command description for ConfigureNodeDescription * @@ -10946,14 +6851,9 @@ * Command: ConfigureNodeDescription * @param description uint8_t* */ -#define emberAfFillCommandInformationClusterConfigureNodeDescription(description) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, \ - "s", \ - description); - +#define emberAfFillCommandInformationClusterConfigureNodeDescription(description) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID, "s", description); /** @brief Command description for ConfigureDeliveryEnable * @@ -10961,14 +6861,9 @@ * Command: ConfigureDeliveryEnable * @param enable uint8_t */ -#define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, \ - "u", \ - enable); - +#define emberAfFillCommandInformationClusterConfigureDeliveryEnable(enable) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID, "u", enable); /** @brief Command description for ConfigurePushInformationTimer * @@ -10976,14 +6871,9 @@ * Command: ConfigurePushInformationTimer * @param timer uint32_t */ -#define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, \ - "w", \ - timer); - +#define emberAfFillCommandInformationClusterConfigurePushInformationTimer(timer) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID, "w", timer); /** @brief Command description for ConfigureSetRootId * @@ -10991,14 +6881,9 @@ * Command: ConfigureSetRootId * @param rootId uint16_t */ -#define emberAfFillCommandInformationClusterConfigureSetRootId(rootId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, \ - "v", \ - rootId); - +#define emberAfFillCommandInformationClusterConfigureSetRootId(rootId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID, "v", rootId); /** @brief Command description for RequestInformationResponse * @@ -11008,18 +6893,9 @@ * @param buffer uint8_t* * @param bufferLen uint16_t */ -#define emberAfFillCommandInformationClusterRequestInformationResponse(number, \ - buffer, \ - bufferLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID, \ - "ub", \ - number, \ - buffer, \ - bufferLen); - +#define emberAfFillCommandInformationClusterRequestInformationResponse(number, buffer, bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID, "ub", number, buffer, bufferLen); /** @brief Command description for PushInformation * @@ -11028,16 +6904,9 @@ * @param contents uint8_t* * @param contentsLen uint16_t */ -#define emberAfFillCommandInformationClusterPushInformation(contents, \ - contentsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_PUSH_INFORMATION_COMMAND_ID, \ - "b", \ - contents, \ - contentsLen); - +#define emberAfFillCommandInformationClusterPushInformation(contents, contentsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_PUSH_INFORMATION_COMMAND_ID, "b", contents, contentsLen); /** @brief Command description for SendPreferenceResponse * @@ -11046,29 +6915,18 @@ * @param statusFeedbackList uint8_t* * @param statusFeedbackListLen uint16_t */ -#define emberAfFillCommandInformationClusterSendPreferenceResponse(statusFeedbackList, \ - statusFeedbackListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID, \ - "b", \ - statusFeedbackList, \ - statusFeedbackListLen); - +#define emberAfFillCommandInformationClusterSendPreferenceResponse(statusFeedbackList, statusFeedbackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID, "b", statusFeedbackList, statusFeedbackListLen); /** @brief Command description for ServerRequestPreference * * Cluster: Information, Provides commands and attributes for information delivery service on ZigBee networks. * Command: ServerRequestPreference */ -#define emberAfFillCommandInformationClusterServerRequestPreference() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandInformationClusterServerRequestPreference() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID, ""); /** @brief Command description for RequestPreferenceConfirmation * @@ -11077,16 +6935,9 @@ * @param statusFeedbackList uint8_t* * @param statusFeedbackListLen uint16_t */ -#define emberAfFillCommandInformationClusterRequestPreferenceConfirmation(statusFeedbackList, \ - statusFeedbackListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_REQUEST_PREFERENCE_CONFIRMATION_COMMAND_ID, \ - "b", \ - statusFeedbackList, \ - statusFeedbackListLen); - +#define emberAfFillCommandInformationClusterRequestPreferenceConfirmation(statusFeedbackList, statusFeedbackListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_REQUEST_PREFERENCE_CONFIRMATION_COMMAND_ID, "b", statusFeedbackList, statusFeedbackListLen); /** @brief Command description for UpdateResponse * @@ -11095,16 +6946,9 @@ * @param notificationList uint8_t* * @param notificationListLen uint16_t */ -#define emberAfFillCommandInformationClusterUpdateResponse(notificationList, \ - notificationListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_UPDATE_RESPONSE_COMMAND_ID, \ - "b", \ - notificationList, \ - notificationListLen); - +#define emberAfFillCommandInformationClusterUpdateResponse(notificationList, notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_UPDATE_RESPONSE_COMMAND_ID, "b", notificationList, notificationListLen); /** @brief Command description for DeleteResponse * @@ -11113,20 +6957,12 @@ * @param notificationList uint8_t* * @param notificationListLen uint16_t */ -#define emberAfFillCommandInformationClusterDeleteResponse(notificationList, \ - notificationListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_INFORMATION_CLUSTER_ID, \ - ZCL_DELETE_RESPONSE_COMMAND_ID, \ - "b", \ - notificationList, \ - notificationListLen); - +#define emberAfFillCommandInformationClusterDeleteResponse(notificationList, notificationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_INFORMATION_CLUSTER_ID, \ + ZCL_DELETE_RESPONSE_COMMAND_ID, "b", notificationList, notificationListLen); /** @} END Information Commands */ - /** @name Data Sharing Commands */ // @{ /** @brief Command description for ReadFileRequest @@ -11137,18 +6973,11 @@ * @param fileStartPositionAndRequestedOctetCount uint8_t* * @param fileStartPositionAndRequestedOctetCountLen uint16_t */ -#define emberAfFillCommandDataSharingClusterReadFileRequest(fileIndex, \ - fileStartPositionAndRequestedOctetCount, \ - fileStartPositionAndRequestedOctetCountLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_READ_FILE_REQUEST_COMMAND_ID, \ - "vb", \ - fileIndex, \ - fileStartPositionAndRequestedOctetCount, \ - fileStartPositionAndRequestedOctetCountLen); - +#define emberAfFillCommandDataSharingClusterReadFileRequest(fileIndex, fileStartPositionAndRequestedOctetCount, \ + fileStartPositionAndRequestedOctetCountLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_READ_FILE_REQUEST_COMMAND_ID, "vb", fileIndex, fileStartPositionAndRequestedOctetCount, \ + fileStartPositionAndRequestedOctetCountLen); /** @brief Command description for ReadRecordRequest * @@ -11158,18 +6987,11 @@ * @param fileStartRecordAndRequestedRecordCount uint8_t* * @param fileStartRecordAndRequestedRecordCountLen uint16_t */ -#define emberAfFillCommandDataSharingClusterReadRecordRequest(fileIndex, \ - fileStartRecordAndRequestedRecordCount, \ - fileStartRecordAndRequestedRecordCountLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_READ_RECORD_REQUEST_COMMAND_ID, \ - "vb", \ - fileIndex, \ - fileStartRecordAndRequestedRecordCount, \ - fileStartRecordAndRequestedRecordCountLen); - +#define emberAfFillCommandDataSharingClusterReadRecordRequest(fileIndex, fileStartRecordAndRequestedRecordCount, \ + fileStartRecordAndRequestedRecordCountLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_READ_RECORD_REQUEST_COMMAND_ID, "vb", fileIndex, fileStartRecordAndRequestedRecordCount, \ + fileStartRecordAndRequestedRecordCountLen); /** @brief Command description for WriteFileResponse * @@ -11179,18 +7001,9 @@ * @param fileIndex uint8_t* * @param fileIndexLen uint16_t */ -#define emberAfFillCommandDataSharingClusterWriteFileResponse(status, \ - fileIndex, \ - fileIndexLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, \ - "ub", \ - status, \ - fileIndex, \ - fileIndexLen); - +#define emberAfFillCommandDataSharingClusterWriteFileResponse(status, fileIndex, fileIndexLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_WRITE_FILE_RESPONSE_COMMAND_ID, "ub", status, fileIndex, fileIndexLen); /** @brief Command description for WriteFileRequest * @@ -11200,18 +7013,9 @@ * @param fileSize uint8_t* * @param fileSizeLen uint16_t */ -#define emberAfFillCommandDataSharingClusterWriteFileRequest(writeOptions, \ - fileSize, \ - fileSizeLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_WRITE_FILE_REQUEST_COMMAND_ID, \ - "ub", \ - writeOptions, \ - fileSize, \ - fileSizeLen); - +#define emberAfFillCommandDataSharingClusterWriteFileRequest(writeOptions, fileSize, fileSizeLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_WRITE_FILE_REQUEST_COMMAND_ID, "ub", writeOptions, fileSize, fileSizeLen); /** @brief Command description for ModifyFileRequest * @@ -11221,18 +7025,9 @@ * @param fileStartPosition uint32_t * @param octetCount uint32_t */ -#define emberAfFillCommandDataSharingClusterModifyFileRequest(fileIndex, \ - fileStartPosition, \ - octetCount) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_MODIFY_FILE_REQUEST_COMMAND_ID, \ - "vww", \ - fileIndex, \ - fileStartPosition, \ - octetCount); - +#define emberAfFillCommandDataSharingClusterModifyFileRequest(fileIndex, fileStartPosition, octetCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_MODIFY_FILE_REQUEST_COMMAND_ID, "vww", fileIndex, fileStartPosition, octetCount); /** @brief Command description for ModifyRecordRequest * @@ -11242,18 +7037,9 @@ * @param fileStartRecord uint16_t * @param recordCount uint16_t */ -#define emberAfFillCommandDataSharingClusterModifyRecordRequest(fileIndex, \ - fileStartRecord, \ - recordCount) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_MODIFY_RECORD_REQUEST_COMMAND_ID, \ - "vvv", \ - fileIndex, \ - fileStartRecord, \ - recordCount); - +#define emberAfFillCommandDataSharingClusterModifyRecordRequest(fileIndex, fileStartRecord, recordCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_MODIFY_RECORD_REQUEST_COMMAND_ID, "vvv", fileIndex, fileStartRecord, recordCount); /** @brief Command description for FileTransmission * @@ -11263,18 +7049,9 @@ * @param buffer uint8_t* * @param bufferLen uint16_t */ -#define emberAfFillCommandDataSharingClusterFileTransmission(transmitOptions, \ - buffer, \ - bufferLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_FILE_TRANSMISSION_COMMAND_ID, \ - "ub", \ - transmitOptions, \ - buffer, \ - bufferLen); - +#define emberAfFillCommandDataSharingClusterFileTransmission(transmitOptions, buffer, bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_FILE_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen); /** @brief Command description for RecordTransmission * @@ -11284,22 +7061,12 @@ * @param buffer uint8_t* * @param bufferLen uint16_t */ -#define emberAfFillCommandDataSharingClusterRecordTransmission(transmitOptions, \ - buffer, \ - bufferLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_SHARING_CLUSTER_ID, \ - ZCL_RECORD_TRANSMISSION_COMMAND_ID, \ - "ub", \ - transmitOptions, \ - buffer, \ - bufferLen); - +#define emberAfFillCommandDataSharingClusterRecordTransmission(transmitOptions, buffer, bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_DATA_SHARING_CLUSTER_ID, \ + ZCL_RECORD_TRANSMISSION_COMMAND_ID, "ub", transmitOptions, buffer, bufferLen); /** @} END Data Sharing Commands */ - /** @name Gaming Commands */ // @{ /** @brief Command description for SearchGame @@ -11309,16 +7076,9 @@ * @param specificGame uint8_t * @param gameId uint16_t */ -#define emberAfFillCommandGamingClusterSearchGame(specificGame, \ - gameId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_SEARCH_GAME_COMMAND_ID, \ - "uv", \ - specificGame, \ - gameId); - +#define emberAfFillCommandGamingClusterSearchGame(specificGame, gameId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_SEARCH_GAME_COMMAND_ID, "uv", specificGame, gameId); /** @brief Command description for JoinGame * @@ -11328,96 +7088,63 @@ * @param joinAsMaster uint8_t * @param nameOfGame uint8_t* */ -#define emberAfFillCommandGamingClusterJoinGame(gameId, \ - joinAsMaster, \ - nameOfGame) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_JOIN_GAME_COMMAND_ID, \ - "vus", \ - gameId, \ - joinAsMaster, \ - nameOfGame); - +#define emberAfFillCommandGamingClusterJoinGame(gameId, joinAsMaster, nameOfGame) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_JOIN_GAME_COMMAND_ID, "vus", gameId, joinAsMaster, nameOfGame); /** @brief Command description for StartGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: StartGame */ -#define emberAfFillCommandGamingClusterStartGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_START_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterStartGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_START_GAME_COMMAND_ID, ""); /** @brief Command description for PauseGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: PauseGame */ -#define emberAfFillCommandGamingClusterPauseGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_PAUSE_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterPauseGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_PAUSE_GAME_COMMAND_ID, ""); /** @brief Command description for ResumeGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: ResumeGame */ -#define emberAfFillCommandGamingClusterResumeGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_RESUME_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterResumeGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_RESUME_GAME_COMMAND_ID, ""); /** @brief Command description for QuitGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: QuitGame */ -#define emberAfFillCommandGamingClusterQuitGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_QUIT_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterQuitGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_QUIT_GAME_COMMAND_ID, ""); /** @brief Command description for EndGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: EndGame */ -#define emberAfFillCommandGamingClusterEndGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_END_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterEndGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_END_GAME_COMMAND_ID, ""); /** @brief Command description for StartOver * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: StartOver */ -#define emberAfFillCommandGamingClusterStartOver() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_START_OVER_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterStartOver() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_START_OVER_COMMAND_ID, ""); /** @brief Command description for ActionControl * @@ -11425,27 +7152,18 @@ * Command: ActionControl * @param actions uint32_t */ -#define emberAfFillCommandGamingClusterActionControl(actions) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_ACTION_CONTROL_COMMAND_ID, \ - "w", \ - actions); - +#define emberAfFillCommandGamingClusterActionControl(actions) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_ACTION_CONTROL_COMMAND_ID, "w", actions); /** @brief Command description for DownloadGame * * Cluster: Gaming, Attributes and commands to support gaming functions of ZigBee-enabled mobile terminals. * Command: DownloadGame */ -#define emberAfFillCommandGamingClusterDownloadGame() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_DOWNLOAD_GAME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandGamingClusterDownloadGame() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_GAMING_CLUSTER_ID, \ + ZCL_DOWNLOAD_GAME_COMMAND_ID, ""); /** @brief Command description for GameAnnouncement * @@ -11455,18 +7173,9 @@ * @param gameMaster uint8_t * @param listOfGame uint8_t* */ -#define emberAfFillCommandGamingClusterGameAnnouncement(gameId, \ - gameMaster, \ - listOfGame) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_GAME_ANNOUNCEMENT_COMMAND_ID, \ - "vus", \ - gameId, \ - gameMaster, \ - listOfGame); - +#define emberAfFillCommandGamingClusterGameAnnouncement(gameId, gameMaster, listOfGame) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GAMING_CLUSTER_ID, \ + ZCL_GAME_ANNOUNCEMENT_COMMAND_ID, "vus", gameId, gameMaster, listOfGame); /** @brief Command description for GeneralResponse * @@ -11476,108 +7185,67 @@ * @param status uint8_t * @param message uint8_t* */ -#define emberAfFillCommandGamingClusterGeneralResponse(commandId, \ - status, \ - message) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_GAMING_CLUSTER_ID, \ - ZCL_GENERAL_RESPONSE_COMMAND_ID, \ - "uus", \ - commandId, \ - status, \ - message); - +#define emberAfFillCommandGamingClusterGeneralResponse(commandId, status, message) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_GAMING_CLUSTER_ID, \ + ZCL_GENERAL_RESPONSE_COMMAND_ID, "uus", commandId, status, message); /** @} END Gaming Commands */ - /** @name Data Rate Control Commands */ // @{ /** @brief Command description for PathCreation * - * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. - * Command: PathCreation + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and + * attributes which form this interface. Command: PathCreation * @param originatorAddress uint16_t * @param destinationAddress uint16_t * @param dataRate uint8_t */ -#define emberAfFillCommandDataRateControlClusterPathCreation(originatorAddress, \ - destinationAddress, \ - dataRate) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ - ZCL_PATH_CREATION_COMMAND_ID, \ - "vvu", \ - originatorAddress, \ - destinationAddress, \ - dataRate); - +#define emberAfFillCommandDataRateControlClusterPathCreation(originatorAddress, destinationAddress, dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, ZCL_PATH_CREATION_COMMAND_ID, "vvu", originatorAddress, \ + destinationAddress, dataRate); /** @brief Command description for DataRateNotification * - * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. - * Command: DataRateNotification + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and + * attributes which form this interface. Command: DataRateNotification * @param originatorAddress uint16_t * @param destinationAddress uint16_t * @param dataRate uint8_t */ -#define emberAfFillCommandDataRateControlClusterDataRateNotification(originatorAddress, \ - destinationAddress, \ - dataRate) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ - ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, \ - "vvu", \ - originatorAddress, \ - destinationAddress, \ - dataRate); - +#define emberAfFillCommandDataRateControlClusterDataRateNotification(originatorAddress, destinationAddress, dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID, "vvu", originatorAddress, \ + destinationAddress, dataRate); /** @brief Command description for PathDeletion * - * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. - * Command: PathDeletion + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and + * attributes which form this interface. Command: PathDeletion * @param originatorAddress uint16_t * @param destinationAddress uint16_t */ -#define emberAfFillCommandDataRateControlClusterPathDeletion(originatorAddress, \ - destinationAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ - ZCL_PATH_DELETION_COMMAND_ID, \ - "vv", \ - originatorAddress, \ - destinationAddress); - +#define emberAfFillCommandDataRateControlClusterPathDeletion(originatorAddress, destinationAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, ZCL_PATH_DELETION_COMMAND_ID, "vv", originatorAddress, \ + destinationAddress); /** @brief Command description for DataRateControl * - * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and attributes which form this interface. - * Command: DataRateControl + * Cluster: Data Rate Control, This cluster seeks to give applications a means to managing data rate. It provides commands and + * attributes which form this interface. Command: DataRateControl * @param originatorAddress uint16_t * @param destinationAddress uint16_t * @param dataRate uint8_t */ -#define emberAfFillCommandDataRateControlClusterDataRateControl(originatorAddress, \ - destinationAddress, \ - dataRate) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_DATA_RATE_CONTROL_CLUSTER_ID, \ - ZCL_DATA_RATE_CONTROL_COMMAND_ID, \ - "vvu", \ - originatorAddress, \ - destinationAddress, \ - dataRate); - +#define emberAfFillCommandDataRateControlClusterDataRateControl(originatorAddress, destinationAddress, dataRate) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_DATA_RATE_CONTROL_CLUSTER_ID, ZCL_DATA_RATE_CONTROL_COMMAND_ID, "vvu", originatorAddress, \ + destinationAddress, dataRate); /** @} END Data Rate Control Commands */ - /** @name Voice over ZigBee Commands */ // @{ /** @brief Command description for EstablishmentRequest @@ -11592,26 +7260,11 @@ * @param buffer uint8_t* * @param bufferLen uint16_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentRequest(flag, \ - codecType, \ - sampFreq, \ - codecRate, \ - serviceType, \ - buffer, \ - bufferLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, \ - "uuuuub", \ - flag, \ - codecType, \ - sampFreq, \ - codecRate, \ - serviceType, \ - buffer, \ - bufferLen); - +#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentRequest(flag, codecType, sampFreq, codecRate, serviceType, buffer, \ + bufferLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID, "uuuuub", flag, codecType, \ + sampFreq, codecRate, serviceType, buffer, bufferLen); /** @brief Command description for VoiceTransmission * @@ -11620,29 +7273,18 @@ * @param voiceData uint8_t* * @param voiceDataLen uint16_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmission(voiceData, \ - voiceDataLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_VOICE_TRANSMISSION_COMMAND_ID, \ - "b", \ - voiceData, \ - voiceDataLen); - +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmission(voiceData, voiceDataLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_VOICE_TRANSMISSION_COMMAND_ID, "b", voiceData, voiceDataLen); /** @brief Command description for VoiceTransmissionCompletion * * Cluster: Voice over ZigBee, This cluster seeks to provide an interface to a voice over ZigBee protocol. * Command: VoiceTransmissionCompletion */ -#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionCompletion() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionCompletion() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID, ""); /** @brief Command description for ControlResponse * @@ -11650,14 +7292,9 @@ * Command: ControlResponse * @param ackNack uint8_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterControlResponse(ackNack) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_CONTROL_RESPONSE_COMMAND_ID, \ - "u", \ - ackNack); - +#define emberAfFillCommandVoiceOverZigbeeClusterControlResponse(ackNack) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_CONTROL_RESPONSE_COMMAND_ID, "u", ackNack); /** @brief Command description for EstablishmentResponse * @@ -11666,16 +7303,9 @@ * @param ackNack uint8_t * @param codecType uint8_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentResponse(ackNack, \ - codecType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID, \ - "uu", \ - ackNack, \ - codecType); - +#define emberAfFillCommandVoiceOverZigbeeClusterEstablishmentResponse(ackNack, codecType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID, "uu", ackNack, codecType); /** @brief Command description for VoiceTransmissionResponse * @@ -11684,16 +7314,10 @@ * @param sequenceNumber uint8_t * @param errorFlag uint8_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionResponse(sequenceNumber, \ - errorFlag) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_VOICE_TRANSMISSION_RESPONSE_COMMAND_ID, \ - "uu", \ - sequenceNumber, \ - errorFlag); - +#define emberAfFillCommandVoiceOverZigbeeClusterVoiceTransmissionResponse(sequenceNumber, errorFlag) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_VOICE_TRANSMISSION_RESPONSE_COMMAND_ID, "uu", sequenceNumber, \ + errorFlag); /** @brief Command description for Control * @@ -11701,18 +7325,12 @@ * Command: Control * @param controlType uint8_t */ -#define emberAfFillCommandVoiceOverZigbeeClusterControl(controlType) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, \ - ZCL_CONTROL_COMMAND_ID, \ - "u", \ - controlType); - +#define emberAfFillCommandVoiceOverZigbeeClusterControl(controlType) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, ZCL_CONTROL_COMMAND_ID, "u", controlType); /** @} END Voice over ZigBee Commands */ - /** @name Chatting Commands */ // @{ /** @brief Command description for JoinChatRequest @@ -11723,18 +7341,9 @@ * @param nickname uint8_t* * @param cid uint16_t */ -#define emberAfFillCommandChattingClusterJoinChatRequest(uid, \ - nickname, \ - cid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, \ - "vsv", \ - uid, \ - nickname, \ - cid); - +#define emberAfFillCommandChattingClusterJoinChatRequest(uid, nickname, cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_JOIN_CHAT_REQUEST_COMMAND_ID, "vsv", uid, nickname, cid); /** @brief Command description for LeaveChatRequest * @@ -11743,29 +7352,18 @@ * @param cid uint16_t * @param uid uint16_t */ -#define emberAfFillCommandChattingClusterLeaveChatRequest(cid, \ - uid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, \ - "vv", \ - cid, \ - uid); - +#define emberAfFillCommandChattingClusterLeaveChatRequest(cid, uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID, "vv", cid, uid); /** @brief Command description for SearchChatRequest * * Cluster: Chatting, Commands and attributes for sending chat messages among ZigBee devices. * Command: SearchChatRequest */ -#define emberAfFillCommandChattingClusterSearchChatRequest() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, \ - ""); - +#define emberAfFillCommandChattingClusterSearchChatRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID, ""); /** @brief Command description for SwitchChairmanResponse * @@ -11774,16 +7372,9 @@ * @param cid uint16_t * @param uid uint16_t */ -#define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, \ - uid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, \ - "vv", \ - cid, \ - uid); - +#define emberAfFillCommandChattingClusterSwitchChairmanResponse(cid, uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID, "vv", cid, uid); /** @brief Command description for StartChatRequest * @@ -11793,18 +7384,9 @@ * @param uid uint16_t * @param nickname uint8_t* */ -#define emberAfFillCommandChattingClusterStartChatRequest(name, \ - uid, \ - nickname) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_START_CHAT_REQUEST_COMMAND_ID, \ - "svs", \ - name, \ - uid, \ - nickname); - +#define emberAfFillCommandChattingClusterStartChatRequest(name, uid, nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_START_CHAT_REQUEST_COMMAND_ID, "svs", name, uid, nickname); /** @brief Command description for ChatMessage * @@ -11816,22 +7398,9 @@ * @param nickname uint8_t* * @param message uint8_t* */ -#define emberAfFillCommandChattingClusterChatMessage(destinationUid, \ - sourceUid, \ - cid, \ - nickname, \ - message) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_CHAT_MESSAGE_COMMAND_ID, \ - "vvvss", \ - destinationUid, \ - sourceUid, \ - cid, \ - nickname, \ - message); - +#define emberAfFillCommandChattingClusterChatMessage(destinationUid, sourceUid, cid, nickname, message) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_CHAT_MESSAGE_COMMAND_ID, "vvvss", destinationUid, sourceUid, cid, nickname, message); /** @brief Command description for GetNodeInformationRequest * @@ -11840,16 +7409,9 @@ * @param cid uint16_t * @param uid uint16_t */ -#define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, \ - uid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, \ - "vv", \ - cid, \ - uid); - +#define emberAfFillCommandChattingClusterGetNodeInformationRequest(cid, uid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID, "vv", cid, uid); /** @brief Command description for StartChatResponse * @@ -11858,16 +7420,9 @@ * @param status uint8_t * @param cid uint16_t */ -#define emberAfFillCommandChattingClusterStartChatResponse(status, \ - cid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_START_CHAT_RESPONSE_COMMAND_ID, \ - "uv", \ - status, \ - cid); - +#define emberAfFillCommandChattingClusterStartChatResponse(status, cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_START_CHAT_RESPONSE_COMMAND_ID, "uv", status, cid); /** @brief Command description for JoinChatResponse * @@ -11878,20 +7433,9 @@ * @param chatParticipantList uint8_t* * @param chatParticipantListLen uint16_t */ -#define emberAfFillCommandChattingClusterJoinChatResponse(status, \ - cid, \ - chatParticipantList, \ - chatParticipantListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID, \ - "uvb", \ - status, \ - cid, \ - chatParticipantList, \ - chatParticipantListLen); - +#define emberAfFillCommandChattingClusterJoinChatResponse(status, cid, chatParticipantList, chatParticipantListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID, "uvb", status, cid, chatParticipantList, chatParticipantListLen); /** @brief Command description for UserLeft * @@ -11901,18 +7445,9 @@ * @param uid uint16_t * @param nickname uint8_t* */ -#define emberAfFillCommandChattingClusterUserLeft(cid, \ - uid, \ - nickname) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_USER_LEFT_COMMAND_ID, \ - "vvs", \ - cid, \ - uid, \ - nickname); - +#define emberAfFillCommandChattingClusterUserLeft(cid, uid, nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_USER_LEFT_COMMAND_ID, "vvs", cid, uid, nickname); /** @brief Command description for UserJoined * @@ -11922,18 +7457,9 @@ * @param uid uint16_t * @param nickname uint8_t* */ -#define emberAfFillCommandChattingClusterUserJoined(cid, \ - uid, \ - nickname) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_USER_JOINED_COMMAND_ID, \ - "vvs", \ - cid, \ - uid, \ - nickname); - +#define emberAfFillCommandChattingClusterUserJoined(cid, uid, nickname) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_USER_JOINED_COMMAND_ID, "vvs", cid, uid, nickname); /** @brief Command description for SearchChatResponse * @@ -11943,18 +7469,9 @@ * @param chatRoomList uint8_t* * @param chatRoomListLen uint16_t */ -#define emberAfFillCommandChattingClusterSearchChatResponse(options, \ - chatRoomList, \ - chatRoomListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID, \ - "ub", \ - options, \ - chatRoomList, \ - chatRoomListLen); - +#define emberAfFillCommandChattingClusterSearchChatResponse(options, chatRoomList, chatRoomListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID, "ub", options, chatRoomList, chatRoomListLen); /** @brief Command description for SwitchChairmanRequest * @@ -11962,14 +7479,9 @@ * Command: SwitchChairmanRequest * @param cid uint16_t */ -#define emberAfFillCommandChattingClusterSwitchChairmanRequest(cid) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID, \ - "v", \ - cid); - +#define emberAfFillCommandChattingClusterSwitchChairmanRequest(cid) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID, "v", cid); /** @brief Command description for SwitchChairmanConfirm * @@ -11979,18 +7491,9 @@ * @param nodeInformationList uint8_t* * @param nodeInformationListLen uint16_t */ -#define emberAfFillCommandChattingClusterSwitchChairmanConfirm(cid, \ - nodeInformationList, \ - nodeInformationListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID, \ - "vb", \ - cid, \ - nodeInformationList, \ - nodeInformationListLen); - +#define emberAfFillCommandChattingClusterSwitchChairmanConfirm(cid, nodeInformationList, nodeInformationListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID, "vb", cid, nodeInformationList, nodeInformationListLen); /** @brief Command description for SwitchChairmanNotification * @@ -12001,20 +7504,9 @@ * @param address uint16_t * @param endpoint uint8_t */ -#define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, \ - uid, \ - address, \ - endpoint) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, \ - "vvvu", \ - cid, \ - uid, \ - address, \ - endpoint); - +#define emberAfFillCommandChattingClusterSwitchChairmanNotification(cid, uid, address, endpoint) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID, "vvvu", cid, uid, address, endpoint); /** @brief Command description for GetNodeInformationResponse * @@ -12026,26 +7518,14 @@ * @param addressEndpointAndNickname uint8_t* * @param addressEndpointAndNicknameLen uint16_t */ -#define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, \ - cid, \ - uid, \ - addressEndpointAndNickname, \ - addressEndpointAndNicknameLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_CHATTING_CLUSTER_ID, \ - ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, \ - "uvvb", \ - status, \ - cid, \ - uid, \ - addressEndpointAndNickname, \ - addressEndpointAndNicknameLen); - +#define emberAfFillCommandChattingClusterGetNodeInformationResponse(status, cid, uid, addressEndpointAndNickname, \ + addressEndpointAndNicknameLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_CHATTING_CLUSTER_ID, \ + ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID, "uvvb", status, cid, uid, addressEndpointAndNickname, \ + addressEndpointAndNicknameLen); /** @} END Chatting Commands */ - /** @name Payment Commands */ // @{ /** @brief Command description for BuyRequest @@ -12057,20 +7537,9 @@ * @param serviceId uint16_t * @param goodId uint8_t* */ -#define emberAfFillCommandPaymentClusterBuyRequest(userId, \ - userType, \ - serviceId, \ - goodId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_BUY_REQUEST_COMMAND_ID, \ - "svvs", \ - userId, \ - userType, \ - serviceId, \ - goodId); - +#define emberAfFillCommandPaymentClusterBuyRequest(userId, userType, serviceId, goodId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_BUY_REQUEST_COMMAND_ID, "svvs", userId, userType, serviceId, goodId); /** @brief Command description for AcceptPayment * @@ -12081,20 +7550,9 @@ * @param serviceId uint16_t * @param goodId uint8_t* */ -#define emberAfFillCommandPaymentClusterAcceptPayment(userId, \ - userType, \ - serviceId, \ - goodId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_ACCEPT_PAYMENT_COMMAND_ID, \ - "svvs", \ - userId, \ - userType, \ - serviceId, \ - goodId); - +#define emberAfFillCommandPaymentClusterAcceptPayment(userId, userType, serviceId, goodId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_ACCEPT_PAYMENT_COMMAND_ID, "svvs", userId, userType, serviceId, goodId); /** @brief Command description for PaymentConfirm * @@ -12104,18 +7562,9 @@ * @param transId uint16_t * @param transStatus uint8_t */ -#define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, \ - transId, \ - transStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_PAYMENT_CONFIRM_COMMAND_ID, \ - "svu", \ - serialNumber, \ - transId, \ - transStatus); - +#define emberAfFillCommandPaymentClusterPaymentConfirm(serialNumber, transId, transStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_PAYMENT_CONFIRM_COMMAND_ID, "svu", serialNumber, transId, transStatus); /** @brief Command description for BuyConfirm * @@ -12129,26 +7578,11 @@ * @param transId uint16_t * @param transStatus uint8_t */ -#define emberAfFillCommandPaymentClusterBuyConfirm(serialNumber, \ - currency, \ - priceTrailingDigit, \ - price, \ - timestamp, \ - transId, \ - transStatus) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_BUY_CONFIRM_COMMAND_ID, \ - "swuwsvu", \ - serialNumber, \ - currency, \ - priceTrailingDigit, \ - price, \ - timestamp, \ - transId, \ - transStatus); - +#define emberAfFillCommandPaymentClusterBuyConfirm(serialNumber, currency, priceTrailingDigit, price, timestamp, transId, \ + transStatus) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_BUY_CONFIRM_COMMAND_ID, "swuwsvu", serialNumber, currency, priceTrailingDigit, price, timestamp, \ + transId, transStatus); /** @brief Command description for ReceiptDelivery * @@ -12160,22 +7594,10 @@ * @param price uint32_t * @param timestamp uint8_t* */ -#define emberAfFillCommandPaymentClusterReceiptDelivery(serialNumber, \ - currency, \ - priceTrailingDigit, \ - price, \ - timestamp) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_RECEIPT_DELIVERY_COMMAND_ID, \ - "swuws", \ - serialNumber, \ - currency, \ - priceTrailingDigit, \ - price, \ - timestamp); - +#define emberAfFillCommandPaymentClusterReceiptDelivery(serialNumber, currency, priceTrailingDigit, price, timestamp) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_RECEIPT_DELIVERY_COMMAND_ID, "swuws", serialNumber, currency, priceTrailingDigit, price, \ + timestamp); /** @brief Command description for TransactionEnd * @@ -12184,20 +7606,12 @@ * @param serialNumber uint8_t* * @param status uint8_t */ -#define emberAfFillCommandPaymentClusterTransactionEnd(serialNumber, \ - status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_PAYMENT_CLUSTER_ID, \ - ZCL_TRANSACTION_END_COMMAND_ID, \ - "su", \ - serialNumber, \ - status); - +#define emberAfFillCommandPaymentClusterTransactionEnd(serialNumber, status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_PAYMENT_CLUSTER_ID, \ + ZCL_TRANSACTION_END_COMMAND_ID, "su", serialNumber, status); /** @} END Payment Commands */ - /** @name Billing Commands */ // @{ /** @brief Command description for Subscribe @@ -12208,18 +7622,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterSubscribe(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_SUBSCRIBE_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterSubscribe(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_SUBSCRIBE_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for Unsubscribe * @@ -12229,18 +7634,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterUnsubscribe(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_UNSUBSCRIBE_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterUnsubscribe(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_UNSUBSCRIBE_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for StartBillingSession * @@ -12250,18 +7646,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterStartBillingSession(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_START_BILLING_SESSION_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterStartBillingSession(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_START_BILLING_SESSION_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for StopBillingSession * @@ -12271,18 +7658,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterStopBillingSession(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_STOP_BILLING_SESSION_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterStopBillingSession(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_STOP_BILLING_SESSION_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for BillStatusNotification * @@ -12291,16 +7669,9 @@ * @param userId uint8_t* * @param status uint8_t */ -#define emberAfFillCommandBillingClusterBillStatusNotification(userId, \ - status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, \ - "su", \ - userId, \ - status); - +#define emberAfFillCommandBillingClusterBillStatusNotification(userId, status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID, "su", userId, status); /** @brief Command description for SessionKeepAlive * @@ -12310,18 +7681,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterSessionKeepAlive(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterSessionKeepAlive(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), ZCL_BILLING_CLUSTER_ID, \ + ZCL_SESSION_KEEP_ALIVE_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for CheckBillStatus * @@ -12331,18 +7693,9 @@ * @param serviceId uint16_t * @param serviceProviderId uint16_t */ -#define emberAfFillCommandBillingClusterCheckBillStatus(userId, \ - serviceId, \ - serviceProviderId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_CHECK_BILL_STATUS_COMMAND_ID, \ - "svv", \ - userId, \ - serviceId, \ - serviceProviderId); - +#define emberAfFillCommandBillingClusterCheckBillStatus(userId, serviceId, serviceProviderId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_BILLING_CLUSTER_ID, \ + ZCL_CHECK_BILL_STATUS_COMMAND_ID, "svv", userId, serviceId, serviceProviderId); /** @brief Command description for SendBillRecord * @@ -12354,276 +7707,192 @@ * @param timestamp uint8_t* * @param duration uint16_t */ -#define emberAfFillCommandBillingClusterSendBillRecord(userId, \ - serviceId, \ - serviceProviderId, \ - timestamp, \ - duration) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_BILLING_CLUSTER_ID, \ - ZCL_SEND_BILL_RECORD_COMMAND_ID, \ - "svvsv", \ - userId, \ - serviceId, \ - serviceProviderId, \ - timestamp, \ - duration); - +#define emberAfFillCommandBillingClusterSendBillRecord(userId, serviceId, serviceProviderId, timestamp, duration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), ZCL_BILLING_CLUSTER_ID, \ + ZCL_SEND_BILL_RECORD_COMMAND_ID, "svvsv", userId, serviceId, serviceProviderId, timestamp, \ + duration); /** @} END Billing Commands */ - /** @name Appliance Identification Commands */ // @{ /** @} END Appliance Identification Commands */ - /** @name Meter Identification Commands */ // @{ /** @} END Meter Identification Commands */ - /** @name Appliance Events and Alert Commands */ // @{ /** @brief This basic message is used to retrieve Household Appliance current alerts. * - * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. - * Command: GetAlerts + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as + * "temperature reached" and of an alert such as alarm, fault or warning. Command: GetAlerts */ -#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlerts() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ - ZCL_GET_ALERTS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlerts() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, ZCL_GET_ALERTS_COMMAND_ID, ""); /** @brief This message is used to return household appliance current alerts. * - * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. - * Command: GetAlertsResponse + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as + * "temperature reached" and of an alert such as alarm, fault or warning. Command: GetAlertsResponse * @param alertsCount uint8_t * @param alertStructures uint8_t* * @param alertStructuresLen uint16_t */ -#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlertsResponse(alertsCount, \ - alertStructures, \ - alertStructuresLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ - ZCL_GET_ALERTS_RESPONSE_COMMAND_ID, \ - "ub", \ - alertsCount, \ - alertStructures, \ - alertStructuresLen); - +#define emberAfFillCommandApplianceEventsAndAlertClusterGetAlertsResponse(alertsCount, alertStructures, alertStructuresLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, ZCL_GET_ALERTS_RESPONSE_COMMAND_ID, "ub", alertsCount, \ + alertStructures, alertStructuresLen); /** @brief This message is used to notify the current modification of warning and/or fault conditions. * - * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. - * Command: AlertsNotification + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as + * "temperature reached" and of an alert such as alarm, fault or warning. Command: AlertsNotification * @param alertsCount uint8_t * @param alertStructures uint8_t* * @param alertStructuresLen uint16_t */ -#define emberAfFillCommandApplianceEventsAndAlertClusterAlertsNotification(alertsCount, \ - alertStructures, \ - alertStructuresLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ - ZCL_ALERTS_NOTIFICATION_COMMAND_ID, \ - "ub", \ - alertsCount, \ - alertStructures, \ - alertStructuresLen); - +#define emberAfFillCommandApplianceEventsAndAlertClusterAlertsNotification(alertsCount, alertStructures, alertStructuresLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, ZCL_ALERTS_NOTIFICATION_COMMAND_ID, "ub", alertsCount, \ + alertStructures, alertStructuresLen); /** @brief This message is used to notify an event occurred during the normal working of the appliance. * - * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as "temperature reached" and of an alert such as alarm, fault or warning. - * Command: EventsNotification + * Cluster: Appliance Events and Alert, Attributes and commands for transmitting or notifying the occurrence of an event, such as + * "temperature reached" and of an alert such as alarm, fault or warning. Command: EventsNotification * @param eventHeader uint8_t * @param eventId uint8_t */ -#define emberAfFillCommandApplianceEventsAndAlertClusterEventsNotification(eventHeader, \ - eventId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, \ - ZCL_EVENTS_NOTIFICATION_COMMAND_ID, \ - "uu", \ - eventHeader, \ - eventId); - +#define emberAfFillCommandApplianceEventsAndAlertClusterEventsNotification(eventHeader, eventId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, ZCL_EVENTS_NOTIFICATION_COMMAND_ID, "uu", eventHeader, \ + eventId); /** @} END Appliance Events and Alert Commands */ - /** @name Appliance Statistics Commands */ // @{ -/** @brief The Appliance Statistics Cluster server occasionally sends out a Log Notification command to the devices to which it needs to log information related to statistics (e.g., home gateways) which implement the client side of Appliance Statistics Cluster. +/** @brief The Appliance Statistics Cluster server occasionally sends out a Log Notification command to the devices to which it + * needs to log information related to statistics (e.g., home gateways) which implement the client side of Appliance Statistics + * Cluster. * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: LogNotification + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: LogNotification * @param timeStamp uint32_t * @param logId uint32_t * @param logLength uint32_t * @param logPayload uint8_t* * @param logPayloadLen uint16_t */ -#define emberAfFillCommandApplianceStatisticsClusterLogNotification(timeStamp, \ - logId, \ - logLength, \ - logPayload, \ - logPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_LOG_NOTIFICATION_COMMAND_ID, \ - "wwwb", \ - timeStamp, \ - logId, \ - logLength, \ - logPayload, \ - logPayloadLen); - - -/** @brief The Appliance Statistics Cluster server sends out a Log Response command to respond to a Log Request command generated by the client side of the Appliance Statistics cluster. - * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: LogResponse +#define emberAfFillCommandApplianceStatisticsClusterLogNotification(timeStamp, logId, logLength, logPayload, logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_LOG_NOTIFICATION_COMMAND_ID, "wwwb", timeStamp, logId, \ + logLength, logPayload, logPayloadLen); + +/** @brief The Appliance Statistics Cluster server sends out a Log Response command to respond to a Log Request command generated by + * the client side of the Appliance Statistics cluster. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: LogResponse * @param timeStamp uint32_t * @param logId uint32_t * @param logLength uint32_t * @param logPayload uint8_t* * @param logPayloadLen uint16_t */ -#define emberAfFillCommandApplianceStatisticsClusterLogResponse(timeStamp, \ - logId, \ - logLength, \ - logPayload, \ - logPayloadLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_LOG_RESPONSE_COMMAND_ID, \ - "wwwb", \ - timeStamp, \ - logId, \ - logLength, \ - logPayload, \ - logPayloadLen); - - -/** @brief The Log Queue Response command is generated as a response to a LogQueueRequest command in order to notify the client side of the Appliance statistics cluster about the logs stored in the server side (queue) that can be retrieved by the client side of this cluster through a LogRequest command. - * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: LogQueueResponse +#define emberAfFillCommandApplianceStatisticsClusterLogResponse(timeStamp, logId, logLength, logPayload, logPayloadLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_LOG_RESPONSE_COMMAND_ID, "wwwb", timeStamp, logId, \ + logLength, logPayload, logPayloadLen); + +/** @brief The Log Queue Response command is generated as a response to a LogQueueRequest command in order to notify the client side + * of the Appliance statistics cluster about the logs stored in the server side (queue) that can be retrieved by the client side of + * this cluster through a LogRequest command. + * + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: LogQueueResponse * @param logQueueSize uint8_t * @param logIds uint8_t* * @param logIdsLen uint16_t */ -#define emberAfFillCommandApplianceStatisticsClusterLogQueueResponse(logQueueSize, \ - logIds, \ - logIdsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, \ - "ub", \ - logQueueSize, \ - logIds, \ - logIdsLen); +#define emberAfFillCommandApplianceStatisticsClusterLogQueueResponse(logQueueSize, logIds, logIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID, "ub", logQueueSize, logIds, \ + logIdsLen); - -/** @brief The Appliance Statistics Cluster server sends out a Statistic Available command to notify the client side of the Appliance Statistics cluster that there are statistics that can be retrieved by using the Log Request command. +/** @brief The Appliance Statistics Cluster server sends out a Statistic Available command to notify the client side of the + * Appliance Statistics cluster that there are statistics that can be retrieved by using the Log Request command. * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: StatisticsAvailable + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: StatisticsAvailable * @param logQueueSize uint8_t * @param logIds uint8_t* * @param logIdsLen uint16_t */ -#define emberAfFillCommandApplianceStatisticsClusterStatisticsAvailable(logQueueSize, \ - logIds, \ - logIdsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_STATISTICS_AVAILABLE_COMMAND_ID, \ - "ub", \ - logQueueSize, \ - logIds, \ - logIdsLen); - +#define emberAfFillCommandApplianceStatisticsClusterStatisticsAvailable(logQueueSize, logIds, logIdsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_STATISTICS_AVAILABLE_COMMAND_ID, "ub", logQueueSize, \ + logIds, logIdsLen); -/** @brief The Log request command is sent from a device supporting the client side of the Appliance Statistics cluster (e.g., Home Gateway) to retrieve the log from the device supporting the server side (e.g., appliance). +/** @brief The Log request command is sent from a device supporting the client side of the Appliance Statistics cluster (e.g., Home + * Gateway) to retrieve the log from the device supporting the server side (e.g., appliance). * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: LogRequest + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: LogRequest * @param logId uint32_t */ -#define emberAfFillCommandApplianceStatisticsClusterLogRequest(logId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_LOG_REQUEST_COMMAND_ID, \ - "w", \ - logId); +#define emberAfFillCommandApplianceStatisticsClusterLogRequest(logId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_LOG_REQUEST_COMMAND_ID, "w", logId); - -/** @brief The Log Queue Request command is send from a device supporting the client side of the Appliance Statistics cluster (e.g. Home Gateway) to retrieve the information about the logs inserted in the queue, from the device supporting the server side (e.g. appliance). +/** @brief The Log Queue Request command is send from a device supporting the client side of the Appliance Statistics cluster (e.g. + * Home Gateway) to retrieve the information about the logs inserted in the queue, from the device supporting the server side (e.g. + * appliance). * - * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee payload, the Partition cluster should be used. - * Command: LogQueueRequest + * Cluster: Appliance Statistics, This cluster provides a mechanism for the transmitting appliance statistics to a collection unit + * (gateway). The statistics can be in format of data logs. In case of statistic information that will not fit the single ZigBee + * payload, the Partition cluster should be used. Command: LogQueueRequest */ -#define emberAfFillCommandApplianceStatisticsClusterLogQueueRequest() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, \ - ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, \ - ""); - +#define emberAfFillCommandApplianceStatisticsClusterLogQueueRequest() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, ZCL_LOG_QUEUE_REQUEST_COMMAND_ID, ""); /** @} END Appliance Statistics Commands */ - /** @name Electrical Measurement Commands */ // @{ -/** @brief A function which returns the power profiling information requested in the GetProfileInfo command. The power profiling information consists of a list of attributes which are profiled along with the period used to profile them. +/** @brief A function which returns the power profiling information requested in the GetProfileInfo command. The power profiling + * information consists of a list of attributes which are profiled along with the period used to profile them. * - * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. - * Command: GetProfileInfoResponseCommand + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power + * outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the + * metering cluster.. Command: GetProfileInfoResponseCommand * @param profileCount uint8_t * @param profileIntervalPeriod uint8_t * @param maxNumberOfIntervals uint8_t * @param listOfAttributes uint8_t* * @param listOfAttributesLen uint16_t */ -#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoResponseCommand(profileCount, \ - profileIntervalPeriod, \ - maxNumberOfIntervals, \ - listOfAttributes, \ - listOfAttributesLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ - ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID, \ - "uuub", \ - profileCount, \ - profileIntervalPeriod, \ - maxNumberOfIntervals, \ - listOfAttributes, \ - listOfAttributesLen); - - -/** @brief A function which returns the electricity measurement profile. The electricity measurement profile includes information regarding the amount of time used to capture data related to the flow of electricity as well as the intervals thes - * - * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. - * Command: GetMeasurementProfileResponseCommand +#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoResponseCommand( \ + profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes, listOfAttributesLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID, "uuub", \ + profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes, listOfAttributesLen); + +/** @brief A function which returns the electricity measurement profile. The electricity measurement profile includes information + * regarding the amount of time used to capture data related to the flow of electricity as well as the intervals thes + * + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power + * outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the + * metering cluster.. Command: GetMeasurementProfileResponseCommand * @param startTime uint32_t * @param status uint8_t * @param profileIntervalPeriod uint8_t @@ -12632,69 +7901,44 @@ * @param intervals uint8_t* * @param intervalsLen uint16_t */ -#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileResponseCommand(startTime, \ - status, \ - profileIntervalPeriod, \ - numberOfIntervalsDelivered, \ - attributeId, \ - intervals, \ - intervalsLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ - ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, \ - "wuuuvb", \ - startTime, \ - status, \ - profileIntervalPeriod, \ - numberOfIntervalsDelivered, \ - attributeId, \ - intervals, \ - intervalsLen); - +#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileResponseCommand( \ + startTime, status, profileIntervalPeriod, numberOfIntervalsDelivered, attributeId, intervals, intervalsLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID, \ + "wuuuvb", startTime, status, profileIntervalPeriod, numberOfIntervalsDelivered, attributeId, \ + intervals, intervalsLen); /** @brief A function which retrieves the power profiling information from the electrical measurement server. * - * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. - * Command: GetProfileInfoCommand + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power + * outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the + * metering cluster.. Command: GetProfileInfoCommand */ -#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoCommand() \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ - ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, \ - ""); +#define emberAfFillCommandElectricalMeasurementClusterGetProfileInfoCommand() \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID, ""); - -/** @brief A function which retrieves an electricity measurement profile from the electricity measurement server for a specific attribute Id requested. +/** @brief A function which retrieves an electricity measurement profile from the electricity measurement server for a specific + * attribute Id requested. * - * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the metering cluster.. - * Command: GetMeasurementProfileCommand + * Cluster: Electrical Measurement, Attributes related to the electrical properties of a device. This cluster is used by power + * outlets and other devices that need to provide instantaneous data as opposed to metrology data which should be retrieved from the + * metering cluster.. Command: GetMeasurementProfileCommand * @param attributeId uint16_t * @param startTime uint32_t * @param numberOfIntervals uint8_t */ -#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileCommand(attributeId, \ - startTime, \ - numberOfIntervals) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, \ - ZCL_GET_MEASUREMENT_PROFILE_COMMAND_COMMAND_ID, \ - "vwu", \ - attributeId, \ - startTime, \ - numberOfIntervals); - +#define emberAfFillCommandElectricalMeasurementClusterGetMeasurementProfileCommand(attributeId, startTime, numberOfIntervals) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, ZCL_GET_MEASUREMENT_PROFILE_COMMAND_COMMAND_ID, "vwu", \ + attributeId, startTime, numberOfIntervals); /** @} END Electrical Measurement Commands */ - /** @name Diagnostics Commands */ // @{ /** @} END Diagnostics Commands */ - /** @name ZLL Commissioning Commands */ // @{ /** @brief Command description for ScanRequest @@ -12705,18 +7949,10 @@ * @param zigbeeInformation uint8_t * @param zllInformation uint8_t */ -#define emberAfFillCommandZllCommissioningClusterScanRequest(transaction, \ - zigbeeInformation, \ - zllInformation) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_SCAN_REQUEST_COMMAND_ID, \ - "wuu", \ - transaction, \ - zigbeeInformation, \ - zllInformation); - +#define emberAfFillCommandZllCommissioningClusterScanRequest(transaction, zigbeeInformation, zllInformation) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_SCAN_REQUEST_COMMAND_ID, "wuu", transaction, \ + zigbeeInformation, zllInformation); /** @brief Command description for DeviceInformationRequest * @@ -12725,16 +7961,10 @@ * @param transaction uint32_t * @param startIndex uint8_t */ -#define emberAfFillCommandZllCommissioningClusterDeviceInformationRequest(transaction, \ - startIndex) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, \ - "wu", \ - transaction, \ - startIndex); - +#define emberAfFillCommandZllCommissioningClusterDeviceInformationRequest(transaction, startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID, "wu", transaction, \ + startIndex); /** @brief Command description for IdentifyRequest * @@ -12743,16 +7973,10 @@ * @param transaction uint32_t * @param identifyDuration uint16_t */ -#define emberAfFillCommandZllCommissioningClusterIdentifyRequest(transaction, \ - identifyDuration) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_IDENTIFY_REQUEST_COMMAND_ID, \ - "wv", \ - transaction, \ - identifyDuration); - +#define emberAfFillCommandZllCommissioningClusterIdentifyRequest(transaction, identifyDuration) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_IDENTIFY_REQUEST_COMMAND_ID, "wv", transaction, \ + identifyDuration); /** @brief Command description for ResetToFactoryNewRequest * @@ -12760,14 +7984,9 @@ * Command: ResetToFactoryNewRequest * @param transaction uint32_t */ -#define emberAfFillCommandZllCommissioningClusterResetToFactoryNewRequest(transaction) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, \ - "w", \ - transaction); - +#define emberAfFillCommandZllCommissioningClusterResetToFactoryNewRequest(transaction) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID, "w", transaction); /** @brief Command description for NetworkStartRequest * @@ -12789,42 +8008,16 @@ * @param initiatorIeeeAddress uint8_t* * @param initiatorNetworkAddress uint16_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkStartRequest(transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd, \ - initiatorIeeeAddress, \ - initiatorNetworkAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_START_REQUEST_COMMAND_ID, \ - "w8uGuvvvvvvvv8v", \ - transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd, \ - initiatorIeeeAddress, \ - initiatorNetworkAddress); - +#define emberAfFillCommandZllCommissioningClusterNetworkStartRequest( \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, logicalChannel, panId, networkAddress, groupIdentifiersBegin, \ + groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, \ + freeGroupIdentifierRangeEnd, initiatorIeeeAddress, initiatorNetworkAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_START_REQUEST_COMMAND_ID, "w8uGuvvvvvvvv8v", \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, logicalChannel, panId, networkAddress, \ + groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd, \ + initiatorIeeeAddress, initiatorNetworkAddress); /** @brief Command description for NetworkJoinRouterRequest * @@ -12845,40 +8038,15 @@ * @param freeGroupIdentifierRangeBegin uint16_t * @param freeGroupIdentifierRangeEnd uint16_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterRequest(transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, \ - "w8uGuuvvvvvvvv", \ - transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd); - +#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterRequest( \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress, \ + groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID, "w8uGuuvvvvvvvv", \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, \ + networkAddress, groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd); /** @brief Command description for NetworkJoinEndDeviceRequest * @@ -12899,40 +8067,15 @@ * @param freeGroupIdentifierRangeBegin uint16_t * @param freeGroupIdentifierRangeEnd uint16_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceRequest(transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, \ - "w8uGuuvvvvvvvv", \ - transaction, \ - extendedPanId, \ - keyIndex, \ - encryptedNetworkKey, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - groupIdentifiersBegin, \ - groupIdentifiersEnd, \ - freeNetworkAddressRangeBegin, \ - freeNetworkAddressRangeEnd, \ - freeGroupIdentifierRangeBegin, \ - freeGroupIdentifierRangeEnd); - +#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceRequest( \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, networkAddress, \ + groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin, freeNetworkAddressRangeEnd, \ + freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID, "w8uGuuvvvvvvvv", \ + transaction, extendedPanId, keyIndex, encryptedNetworkKey, networkUpdateId, logicalChannel, panId, \ + networkAddress, groupIdentifiersBegin, groupIdentifiersEnd, freeNetworkAddressRangeBegin, \ + freeNetworkAddressRangeEnd, freeGroupIdentifierRangeBegin, freeGroupIdentifierRangeEnd); /** @brief Command description for NetworkUpdateRequest * @@ -12945,24 +8088,11 @@ * @param panId uint16_t * @param networkAddress uint16_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkUpdateRequest(transaction, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, \ - "w8uuvv", \ - transaction, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress); - +#define emberAfFillCommandZllCommissioningClusterNetworkUpdateRequest(transaction, extendedPanId, networkUpdateId, logicalChannel, \ + panId, networkAddress) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID, "w8uuvv", transaction, \ + extendedPanId, networkUpdateId, logicalChannel, panId, networkAddress); /** @brief Command description for GetGroupIdentifiersRequest * @@ -12970,14 +8100,9 @@ * Command: GetGroupIdentifiersRequest * @param startIndex uint8_t */ -#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersRequest(startIndex) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, \ - "u", \ - startIndex); - +#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID, "u", startIndex); /** @brief Command description for GetEndpointListRequest * @@ -12985,14 +8110,9 @@ * Command: GetEndpointListRequest * @param startIndex uint8_t */ -#define emberAfFillCommandZllCommissioningClusterGetEndpointListRequest(startIndex) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, \ - "u", \ - startIndex); - +#define emberAfFillCommandZllCommissioningClusterGetEndpointListRequest(startIndex) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID, "u", startIndex); /** @brief Command description for ScanResponse * @@ -13017,48 +8137,15 @@ * @param version uint8_t * @param groupIdCount uint8_t */ -#define emberAfFillCommandZllCommissioningClusterScanResponse(transaction, \ - rssiCorrection, \ - zigbeeInformation, \ - zllInformation, \ - keyBitmask, \ - responseId, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - numberOfSubDevices, \ - totalGroupIds, \ - endpointId, \ - profileId, \ - deviceId, \ - version, \ - groupIdCount) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_SCAN_RESPONSE_COMMAND_ID, \ - "wuuuvw8uuvvuuuvvuu", \ - transaction, \ - rssiCorrection, \ - zigbeeInformation, \ - zllInformation, \ - keyBitmask, \ - responseId, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId, \ - networkAddress, \ - numberOfSubDevices, \ - totalGroupIds, \ - endpointId, \ - profileId, \ - deviceId, \ - version, \ - groupIdCount); - +#define emberAfFillCommandZllCommissioningClusterScanResponse( \ + transaction, rssiCorrection, zigbeeInformation, zllInformation, keyBitmask, responseId, extendedPanId, networkUpdateId, \ + logicalChannel, panId, networkAddress, numberOfSubDevices, totalGroupIds, endpointId, profileId, deviceId, version, \ + groupIdCount) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_SCAN_RESPONSE_COMMAND_ID, "wuuuvw8uuvvuuuvvuu", transaction, \ + rssiCorrection, zigbeeInformation, zllInformation, keyBitmask, responseId, extendedPanId, \ + networkUpdateId, logicalChannel, panId, networkAddress, numberOfSubDevices, totalGroupIds, \ + endpointId, profileId, deviceId, version, groupIdCount); /** @brief Command description for DeviceInformationResponse * @@ -13071,24 +8158,13 @@ * @param deviceInformationRecordList uint8_t* * @param deviceInformationRecordListLen uint16_t */ -#define emberAfFillCommandZllCommissioningClusterDeviceInformationResponse(transaction, \ - numberOfSubDevices, \ - startIndex, \ - deviceInformationRecordCount, \ - deviceInformationRecordList, \ - deviceInformationRecordListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, \ - "wuuub", \ - transaction, \ - numberOfSubDevices, \ - startIndex, \ - deviceInformationRecordCount, \ - deviceInformationRecordList, \ - deviceInformationRecordListLen); - +#define emberAfFillCommandZllCommissioningClusterDeviceInformationResponse( \ + transaction, numberOfSubDevices, startIndex, deviceInformationRecordCount, deviceInformationRecordList, \ + deviceInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID, "wuuub", transaction, \ + numberOfSubDevices, startIndex, deviceInformationRecordCount, deviceInformationRecordList, \ + deviceInformationRecordListLen); /** @brief Command description for NetworkStartResponse * @@ -13101,24 +8177,11 @@ * @param logicalChannel uint8_t * @param panId uint16_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkStartResponse(transaction, \ - status, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_START_RESPONSE_COMMAND_ID, \ - "wu8uuv", \ - transaction, \ - status, \ - extendedPanId, \ - networkUpdateId, \ - logicalChannel, \ - panId); - +#define emberAfFillCommandZllCommissioningClusterNetworkStartResponse(transaction, status, extendedPanId, networkUpdateId, \ + logicalChannel, panId) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_START_RESPONSE_COMMAND_ID, "wu8uuv", transaction, \ + status, extendedPanId, networkUpdateId, logicalChannel, panId); /** @brief Command description for NetworkJoinRouterResponse * @@ -13127,16 +8190,10 @@ * @param transaction uint32_t * @param status uint8_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterResponse(transaction, \ - status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, \ - "wu", \ - transaction, \ - status); - +#define emberAfFillCommandZllCommissioningClusterNetworkJoinRouterResponse(transaction, status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID, "wu", transaction, \ + status); /** @brief Command description for NetworkJoinEndDeviceResponse * @@ -13145,16 +8202,10 @@ * @param transaction uint32_t * @param status uint8_t */ -#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceResponse(transaction, \ - status) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, \ - "wu", \ - transaction, \ - status); - +#define emberAfFillCommandZllCommissioningClusterNetworkJoinEndDeviceResponse(transaction, status) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID, "wu", \ + transaction, status); /** @brief Command description for EndpointInformation * @@ -13167,24 +8218,11 @@ * @param deviceId uint16_t * @param version uint8_t */ -#define emberAfFillCommandZllCommissioningClusterEndpointInformation(ieeeAddress, \ - networkAddress, \ - endpointId, \ - profileId, \ - deviceId, \ - version) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_ENDPOINT_INFORMATION_COMMAND_ID, \ - "8vuvvu", \ - ieeeAddress, \ - networkAddress, \ - endpointId, \ - profileId, \ - deviceId, \ - version); - +#define emberAfFillCommandZllCommissioningClusterEndpointInformation(ieeeAddress, networkAddress, endpointId, profileId, deviceId, \ + version) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_ENDPOINT_INFORMATION_COMMAND_ID, "8vuvvu", ieeeAddress, \ + networkAddress, endpointId, profileId, deviceId, version); /** @brief Command description for GetGroupIdentifiersResponse * @@ -13196,22 +8234,11 @@ * @param groupInformationRecordList uint8_t* * @param groupInformationRecordListLen uint16_t */ -#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersResponse(total, \ - startIndex, \ - count, \ - groupInformationRecordList, \ - groupInformationRecordListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID, \ - "uuub", \ - total, \ - startIndex, \ - count, \ - groupInformationRecordList, \ - groupInformationRecordListLen); - +#define emberAfFillCommandZllCommissioningClusterGetGroupIdentifiersResponse(total, startIndex, count, groupInformationRecordList, \ + groupInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID, "uuub", total, \ + startIndex, count, groupInformationRecordList, groupInformationRecordListLen); /** @brief Command description for GetEndpointListResponse * @@ -13223,250 +8250,159 @@ * @param endpointInformationRecordList uint8_t* * @param endpointInformationRecordListLen uint16_t */ -#define emberAfFillCommandZllCommissioningClusterGetEndpointListResponse(total, \ - startIndex, \ - count, \ - endpointInformationRecordList, \ - endpointInformationRecordListLen) \ - emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_ZLL_COMMISSIONING_CLUSTER_ID, \ - ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID, \ - "uuub", \ - total, \ - startIndex, \ - count, \ - endpointInformationRecordList, \ - endpointInformationRecordListLen); - +#define emberAfFillCommandZllCommissioningClusterGetEndpointListResponse(total, startIndex, count, endpointInformationRecordList, \ + endpointInformationRecordListLen) \ + emberAfFillExternalBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_ZLL_COMMISSIONING_CLUSTER_ID, ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID, "uuub", total, \ + startIndex, count, endpointInformationRecordList, endpointInformationRecordListLen); /** @} END ZLL Commissioning Commands */ - /** @name Sample Mfg Specific Cluster Commands */ // @{ /** @brief A sample manufacturer specific command within the sample manufacturer specific cluster. * - * Cluster: Sample Mfg Specific Cluster, This cluster provides an example of how the Application + * Cluster: Sample Mfg Specific Cluster, This cluster provides an example of how the Application Framework can be extended to include manufacturer specific clusters. * Command: CommandOne * @param argOne uint8_t */ -#define emberAfFillCommandSampleMfgSpecificClusterCommandOne(argOne) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, \ - 0x1002, \ - ZCL_COMMAND_ONE_COMMAND_ID, \ - "u", \ - argOne); - +#define emberAfFillCommandSampleMfgSpecificClusterCommandOne(argOne) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, 0x1002, ZCL_COMMAND_ONE_COMMAND_ID, "u", argOne); /** @} END Sample Mfg Specific Cluster Commands */ - /** @name Sample Mfg Specific Cluster 2 Commands */ // @{ /** @brief A sample manufacturer specific command within the sample manufacturer specific cluster. * - * Cluster: Sample Mfg Specific Cluster 2, This cluster provides an example of how the Application + * Cluster: Sample Mfg Specific Cluster 2, This cluster provides an example of how the Application Framework can be extended to include manufacturer specific clusters. * Command: CommandTwo * @param argOne uint8_t */ -#define emberAfFillCommandSampleMfgSpecificCluster2CommandTwo(argOne) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, \ - 0x1049, \ - ZCL_COMMAND_TWO_COMMAND_ID, \ - "u", \ - argOne); - +#define emberAfFillCommandSampleMfgSpecificCluster2CommandTwo(argOne) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, 0x1049, ZCL_COMMAND_TWO_COMMAND_ID, "u", argOne); /** @} END Sample Mfg Specific Cluster 2 Commands */ - /** @name Configuration Cluster Commands */ // @{ /** @brief Command to write a token value over the air. * * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware - parameters. + parameters. * Command: SetToken * @param token uint16_t * @param data uint8_t* */ -#define emberAfFillCommandOtaConfigurationClusterSetToken(token, \ - data) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ - 0x1002, \ - ZCL_SET_TOKEN_COMMAND_ID, \ - "vs", \ - token, \ - data); - +#define emberAfFillCommandOtaConfigurationClusterSetToken(token, data) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, ZCL_SET_TOKEN_COMMAND_ID, "vs", token, data); /** @brief Command to lock the token values. * * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware - parameters. + parameters. * Command: LockTokens */ -#define emberAfFillCommandOtaConfigurationClusterLockTokens() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ - 0x1002, \ - ZCL_LOCK_TOKENS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandOtaConfigurationClusterLockTokens() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, ZCL_LOCK_TOKENS_COMMAND_ID, ""); /** @brief Command to read a token value. * * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware - parameters. + parameters. * Command: ReadTokens * @param token uint16_t */ -#define emberAfFillCommandOtaConfigurationClusterReadTokens(token) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ - 0x1002, \ - ZCL_READ_TOKENS_COMMAND_ID, \ - "v", \ - token); - +#define emberAfFillCommandOtaConfigurationClusterReadTokens(token) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, ZCL_READ_TOKENS_COMMAND_ID, "v", token); /** @brief Command to unlock tokens with a device-specific password (if allowed). * * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware - parameters. + parameters. * Command: UnlockTokens * @param data uint8_t* */ -#define emberAfFillCommandOtaConfigurationClusterUnlockTokens(data) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ - 0x1002, \ - ZCL_UNLOCK_TOKENS_COMMAND_ID, \ - "s", \ - data); - +#define emberAfFillCommandOtaConfigurationClusterUnlockTokens(data) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, ZCL_UNLOCK_TOKENS_COMMAND_ID, "s", data); /** @brief Response to a token value read. * * Cluster: Configuration Cluster, This cluster allows for the OTA configuration of firmware - parameters. + parameters. * Command: ReturnToken * @param token uint16_t * @param data uint8_t* */ -#define emberAfFillCommandOtaConfigurationClusterReturnToken(token, \ - data) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_OTA_CONFIGURATION_CLUSTER_ID, \ - 0x1002, \ - ZCL_RETURN_TOKEN_COMMAND_ID, \ - "vs", \ - token, \ - data); - +#define emberAfFillCommandOtaConfigurationClusterReturnToken(token, data) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, ZCL_RETURN_TOKEN_COMMAND_ID, "vs", token, data); /** @} END Configuration Cluster Commands */ - /** @name MFGLIB Cluster Commands */ // @{ /** @brief Command to put the device into streaming mode. * - * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions - over the air. + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. * Command: stream * @param channel uint8_t * @param power int8_t * @param time uint16_t */ -#define emberAfFillCommandMfglibClusterstream(channel, \ - power, \ - time) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MFGLIB_CLUSTER_ID, \ - 0x1002, \ - ZCL_STREAM_COMMAND_ID, \ - "uuv", \ - channel, \ - power, \ - time); - +#define emberAfFillCommandMfglibClusterstream(channel, power, time) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, 0x1002, ZCL_STREAM_COMMAND_ID, "uuv", channel, power, time); /** @brief Command to put the device into tone mode. * - * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions - over the air. + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. * Command: tone * @param channel uint8_t * @param power int8_t * @param time uint16_t */ -#define emberAfFillCommandMfglibClustertone(channel, \ - power, \ - time) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MFGLIB_CLUSTER_ID, \ - 0x1002, \ - ZCL_TONE_COMMAND_ID, \ - "uuv", \ - channel, \ - power, \ - time); - +#define emberAfFillCommandMfglibClustertone(channel, power, time) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, 0x1002, ZCL_TONE_COMMAND_ID, "uuv", channel, power, time); /** @brief Command to put the device into RX mode. * - * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions - over the air. + * Cluster: MFGLIB Cluster, This cluster provides commands to kick off MFGLIB actions + over the air. * Command: rxMode * @param channel uint8_t * @param power int8_t * @param time uint16_t */ -#define emberAfFillCommandMfglibClusterrxMode(channel, \ - power, \ - time) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_MFGLIB_CLUSTER_ID, \ - 0x1002, \ - ZCL_RX_MODE_COMMAND_ID, \ - "uuv", \ - channel, \ - power, \ - time); - +#define emberAfFillCommandMfglibClusterrxMode(channel, power, time) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_MFGLIB_CLUSTER_ID, 0x1002, ZCL_RX_MODE_COMMAND_ID, "uuv", channel, power, time); /** @} END MFGLIB Cluster Commands */ - /** @name SL Works With All Hubs Commands */ // @{ /** @brief Enable enforcement of APS-level security for all cluster commands. @@ -13477,20 +8413,11 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterEnableApsLinkKeyAuthorization(numberExemptClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, \ - "ub", \ - numberExemptClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterEnableApsLinkKeyAuthorization(numberExemptClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "ub", numberExemptClusters, clusterId, \ + clusterIdLen); /** @brief Disable enforcement of APS-level security for all cluster commands. * @@ -13500,20 +8427,11 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterDisableApsLinkKeyAuthorization(numberExemptClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, \ - "ub", \ - numberExemptClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterDisableApsLinkKeyAuthorization(numberExemptClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID, "ub", numberExemptClusters, clusterId, \ + clusterIdLen); /** @brief Query status of APS-level security enforcement for a specified cluster. * @@ -13521,31 +8439,20 @@ * Command: ApsLinkKeyAuthorizationQuery * @param clusterId uint16_t */ -#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQuery(clusterId) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID, \ - "v", \ - clusterId); - +#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQuery(clusterId) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID, "v", clusterId); /** @brief Trigger device to request a new APS link key from the Trust Center. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: RequestNewApsLinkKey */ -#define emberAfFillCommandSlWwahClusterRequestNewApsLinkKey() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterRequestNewApsLinkKey() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID, ""); /** @brief Enable WWAH App Event retry algorithm. * @@ -13556,52 +8463,32 @@ * @param maxBackoffTimeSeconds uint32_t * @param maxRedeliveryAttempts uint8_t */ -#define emberAfFillCommandSlWwahClusterEnableWwahAppEventRetryAlgorithm(firstBackoffTimeSeconds, \ - backoffSeqCommonRatio, \ - maxBackoffTimeSeconds, \ - maxRedeliveryAttempts) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, \ - "uuwu", \ - firstBackoffTimeSeconds, \ - backoffSeqCommonRatio, \ - maxBackoffTimeSeconds, \ - maxRedeliveryAttempts); - +#define emberAfFillCommandSlWwahClusterEnableWwahAppEventRetryAlgorithm(firstBackoffTimeSeconds, backoffSeqCommonRatio, \ + maxBackoffTimeSeconds, maxRedeliveryAttempts) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, "uuwu", firstBackoffTimeSeconds, \ + backoffSeqCommonRatio, maxBackoffTimeSeconds, maxRedeliveryAttempts); /** @brief Disable WWAH App Event retry algorithm. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableWwahAppEventRetryAlgorithm */ -#define emberAfFillCommandSlWwahClusterDisableWwahAppEventRetryAlgorithm() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableWwahAppEventRetryAlgorithm() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID, ""); /** @brief Trigger device to request current attribute values from Time Cluster server. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: RequestTime */ -#define emberAfFillCommandSlWwahClusterRequestTime() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_REQUEST_TIME_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterRequestTime() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_REQUEST_TIME_COMMAND_ID, ""); /** @brief Enable WWAH rejoin algorithm. * @@ -13613,39 +8500,23 @@ * @param maxBackoffTimeSeconds uint16_t * @param maxBackoffIterations uint16_t */ -#define emberAfFillCommandSlWwahClusterEnableWwahRejoinAlgorithm(fastRejoinTimeoutSeconds, \ - durationBetweenRejoinsSeconds, \ - fastRejoinFirstBackoffSeconds, \ - maxBackoffTimeSeconds, \ - maxBackoffIterations) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, \ - "vvvvv", \ - fastRejoinTimeoutSeconds, \ - durationBetweenRejoinsSeconds, \ - fastRejoinFirstBackoffSeconds, \ - maxBackoffTimeSeconds, \ - maxBackoffIterations); - +#define emberAfFillCommandSlWwahClusterEnableWwahRejoinAlgorithm(fastRejoinTimeoutSeconds, durationBetweenRejoinsSeconds, \ + fastRejoinFirstBackoffSeconds, maxBackoffTimeSeconds, \ + maxBackoffIterations) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, "vvvvv", fastRejoinTimeoutSeconds, \ + durationBetweenRejoinsSeconds, fastRejoinFirstBackoffSeconds, maxBackoffTimeSeconds, maxBackoffIterations); /** @brief Disable WWAH rejoin algorithm. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableWwahRejoinAlgorithm */ -#define emberAfFillCommandSlWwahClusterDisableWwahRejoinAlgorithm() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableWwahRejoinAlgorithm() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID, ""); /** @brief Set the enrollment method of an IAS Zone server. * @@ -13653,31 +8524,20 @@ * Command: SetIasZoneEnrollmentMethod * @param enrollmentMode uint8_t */ -#define emberAfFillCommandSlWwahClusterSetIasZoneEnrollmentMethod(enrollmentMode) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID, \ - "u", \ - enrollmentMode); - +#define emberAfFillCommandSlWwahClusterSetIasZoneEnrollmentMethod(enrollmentMode) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID, "u", enrollmentMode); /** @brief Clear the binding table. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: ClearBindingTable */ -#define emberAfFillCommandSlWwahClusterClearBindingTable() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_CLEAR_BINDING_TABLE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterClearBindingTable() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_CLEAR_BINDING_TABLE_COMMAND_ID, ""); /** @brief Enable device to periodically check connectivity with Zigbee Coordinator. * @@ -13685,31 +8545,20 @@ * Command: EnablePeriodicRouterCheckIns * @param checkInInterval uint16_t */ -#define emberAfFillCommandSlWwahClusterEnablePeriodicRouterCheckIns(checkInInterval) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, \ - "v", \ - checkInInterval); - +#define emberAfFillCommandSlWwahClusterEnablePeriodicRouterCheckIns(checkInInterval) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, "v", checkInInterval); /** @brief Disable device from periodically checking connectivity with Zigbee Coordinator. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisablePeriodicRouterCheckIns */ -#define emberAfFillCommandSlWwahClusterDisablePeriodicRouterCheckIns() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisablePeriodicRouterCheckIns() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID, ""); /** @brief Set MAC poll failure wait time. * @@ -13717,16 +8566,10 @@ * Command: SetMacPollFailureWaitTime * @param waitTime uint8_t */ -#define emberAfFillCommandSlWwahClusterSetMacPollFailureWaitTime(waitTime) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID, \ - "u", \ - waitTime); - +#define emberAfFillCommandSlWwahClusterSetMacPollFailureWaitTime(waitTime) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID, "u", waitTime); /** @brief Set pending network update parameters. * @@ -13735,18 +8578,10 @@ * @param channel uint8_t * @param panId uint16_t */ -#define emberAfFillCommandSlWwahClusterSetPendingNetworkUpdate(channel, \ - panId) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID, \ - "uv", \ - channel, \ - panId); - +#define emberAfFillCommandSlWwahClusterSetPendingNetworkUpdate(channel, panId) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID, "uv", channel, panId); /** @brief Require all unicast commands to have APS ACKs enabled. * @@ -13756,50 +8591,31 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterRequireApsAcksOnUnicasts(numberExemptClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID, \ - "ub", \ - numberExemptClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterRequireApsAcksOnUnicasts(numberExemptClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID, "ub", numberExemptClusters, clusterId, \ + clusterIdLen); /** @brief Roll back changes made by Require APS ACK on Unicasts. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: RemoveApsAcksOnUnicastsRequirement */ -#define emberAfFillCommandSlWwahClusterRemoveApsAcksOnUnicastsRequirement() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterRemoveApsAcksOnUnicastsRequirement() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID, ""); /** @brief Query whether unicast commands are required to have APS ACKs enabled. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: ApsAckRequirementQuery */ -#define emberAfFillCommandSlWwahClusterApsAckRequirementQuery() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterApsAckRequirementQuery() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID, ""); /** @brief Query for specified debug report. * @@ -13807,16 +8623,10 @@ * Command: DebugReportQuery * @param debugReportId uint8_t */ -#define emberAfFillCommandSlWwahClusterDebugReportQuery(debugReportId) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DEBUG_REPORT_QUERY_COMMAND_ID, \ - "u", \ - debugReportId); - +#define emberAfFillCommandSlWwahClusterDebugReportQuery(debugReportId) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DEBUG_REPORT_QUERY_COMMAND_ID, "u", debugReportId); /** @brief Causes device to perform a scan for beacons advertising the device's network. * @@ -13824,166 +8634,110 @@ * Command: SurveyBeacons * @param standardBeacons uint8_t */ -#define emberAfFillCommandSlWwahClusterSurveyBeacons(standardBeacons) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SURVEY_BEACONS_COMMAND_ID, \ - "u", \ - standardBeacons); - +#define emberAfFillCommandSlWwahClusterSurveyBeacons(standardBeacons) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SURVEY_BEACONS_COMMAND_ID, "u", standardBeacons); /** @brief Disallow OTA downgrade of all device firmware components. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableOtaDowngrades */ -#define emberAfFillCommandSlWwahClusterDisableOtaDowngrades() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableOtaDowngrades() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID, ""); /** @brief Causes device to ignore MGMT Leave Without Rejoin commands. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableMgmtLeaveWithoutRejoin */ -#define emberAfFillCommandSlWwahClusterDisableMgmtLeaveWithoutRejoin() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableMgmtLeaveWithoutRejoin() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID, ""); /** @brief Causes device to ignore Touchlink Interpan messages. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableTouchlinkInterpanMessageSupport */ -#define emberAfFillCommandSlWwahClusterDisableTouchlinkInterpanMessageSupport() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableTouchlinkInterpanMessageSupport() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID, ""); /** @brief Enable WWAH Parent Classification advertisements. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: EnableWwahParentClassification */ -#define emberAfFillCommandSlWwahClusterEnableWwahParentClassification() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterEnableWwahParentClassification() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, ""); /** @brief Disable WWAH Parent Classification advertisements. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableWwahParentClassification */ -#define emberAfFillCommandSlWwahClusterDisableWwahParentClassification() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableWwahParentClassification() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID, ""); /** @brief Process only network key rotation commands sent via unicast and encrypted by Trust Center Link Key. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: EnableTcSecurityOnNtwkKeyRotation */ -#define emberAfFillCommandSlWwahClusterEnableTcSecurityOnNtwkKeyRotation() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterEnableTcSecurityOnNtwkKeyRotation() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID, ""); /** @brief Enable WWAH Bad Parent Recovery feature. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: EnableWwahBadParentRecovery */ -#define emberAfFillCommandSlWwahClusterEnableWwahBadParentRecovery() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterEnableWwahBadParentRecovery() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, ""); /** @brief Disable WWAH Bad Parent Recovery feature. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableWwahBadParentRecovery */ -#define emberAfFillCommandSlWwahClusterDisableWwahBadParentRecovery() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableWwahBadParentRecovery() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID, ""); /** @brief Enable Configuration Mode. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: EnableConfigurationMode */ -#define emberAfFillCommandSlWwahClusterEnableConfigurationMode() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterEnableConfigurationMode() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID, ""); /** @brief Disable Configuration Mode. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: DisableConfigurationMode */ -#define emberAfFillCommandSlWwahClusterDisableConfigurationMode() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterDisableConfigurationMode() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID, ""); /** @brief Use only the Trust Center as cluster server for the set of clusters specified. * @@ -13993,35 +8747,21 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServer(numberOfClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID, \ - "ub", \ - numberOfClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServer(numberOfClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID, "ub", numberOfClusters, clusterId, \ + clusterIdLen); /** @brief Causes device to send an appropriate Trust Center for Cluster Server Query Response command. * * Cluster: SL Works With All Hubs, Silicon Labs proprietary attributes and commands for Works With All Hubs functional extensions. * Command: TrustCenterForClusterServerQuery */ -#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQuery() \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID, \ - ""); - +#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQuery() \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_CLIENT_TO_SERVER), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID, ""); /** @brief Command description for SlAPSLinkKeyAuthorizationQueryResponse * @@ -14030,18 +8770,11 @@ * @param clusterId uint16_t * @param apsLinkKeyAuthStatus uint8_t */ -#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQueryResponse(clusterId, \ - apsLinkKeyAuthStatus) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID, \ - "vu", \ - clusterId, \ - apsLinkKeyAuthStatus); - +#define emberAfFillCommandSlWwahClusterApsLinkKeyAuthorizationQueryResponse(clusterId, apsLinkKeyAuthStatus) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID, "vu", clusterId, \ + apsLinkKeyAuthStatus); /** @brief Command description for SlPoweringOffNotification * @@ -14053,24 +8786,12 @@ * @param manufacturerReason uint8_t* * @param manufacturerReasonLen uint16_t */ -#define emberAfFillCommandSlWwahClusterPoweringOffNotification(powerNotificationReason, \ - manufacturerId, \ - manufacturerReasonLength, \ - manufacturerReason, \ - manufacturerReasonLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID, \ - "uvub", \ - powerNotificationReason, \ - manufacturerId, \ - manufacturerReasonLength, \ - manufacturerReason, \ - manufacturerReasonLen); - +#define emberAfFillCommandSlWwahClusterPoweringOffNotification(powerNotificationReason, manufacturerId, manufacturerReasonLength, \ + manufacturerReason, manufacturerReasonLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID, "uvub", powerNotificationReason, manufacturerId, \ + manufacturerReasonLength, manufacturerReason, manufacturerReasonLen); /** @brief Command description for SlPoweringOnNotification * @@ -14082,24 +8803,12 @@ * @param manufacturerReason uint8_t* * @param manufacturerReasonLen uint16_t */ -#define emberAfFillCommandSlWwahClusterPoweringOnNotification(powerNotificationReason, \ - manufacturerId, \ - manufacturerReasonLength, \ - manufacturerReason, \ - manufacturerReasonLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID, \ - "uvub", \ - powerNotificationReason, \ - manufacturerId, \ - manufacturerReasonLength, \ - manufacturerReason, \ - manufacturerReasonLen); - +#define emberAfFillCommandSlWwahClusterPoweringOnNotification(powerNotificationReason, manufacturerId, manufacturerReasonLength, \ + manufacturerReason, manufacturerReasonLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID, "uvub", powerNotificationReason, manufacturerId, \ + manufacturerReasonLength, manufacturerReason, manufacturerReasonLen); /** @brief Command description for SlShortAddressChange * @@ -14108,18 +8817,10 @@ * @param deviceEui64 uint8_t* * @param deviceShort uint16_t */ -#define emberAfFillCommandSlWwahClusterShortAddressChange(deviceEui64, \ - deviceShort) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID, \ - "8v", \ - deviceEui64, \ - deviceShort); - +#define emberAfFillCommandSlWwahClusterShortAddressChange(deviceEui64, deviceShort) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID, "8v", deviceEui64, deviceShort); /** @brief Command description for SlAPSAckEnablementQueryResponse * @@ -14129,20 +8830,11 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterApsAckEnablementQueryResponse(numberExemptClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID, \ - "ub", \ - numberExemptClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterApsAckEnablementQueryResponse(numberExemptClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID, "ub", numberExemptClusters, clusterId, \ + clusterIdLen); /** @brief Command description for SlPowerDescriptorChange * @@ -14153,22 +8845,12 @@ * @param currentPowerSource uint32_t * @param currentPowerSourceLevel uint32_t */ -#define emberAfFillCommandSlWwahClusterPowerDescriptorChange(currentPowerMode, \ - availablePowerSources, \ - currentPowerSource, \ - currentPowerSourceLevel) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID, \ - "wwww", \ - currentPowerMode, \ - availablePowerSources, \ - currentPowerSource, \ - currentPowerSourceLevel); - +#define emberAfFillCommandSlWwahClusterPowerDescriptorChange(currentPowerMode, availablePowerSources, currentPowerSource, \ + currentPowerSourceLevel) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID, "wwww", currentPowerMode, availablePowerSources, \ + currentPowerSource, currentPowerSourceLevel); /** @brief Command description for SlNewDebugReportNotification * @@ -14177,18 +8859,10 @@ * @param debugReportId uint8_t * @param debugReportSize uint32_t */ -#define emberAfFillCommandSlWwahClusterNewDebugReportNotification(debugReportId, \ - debugReportSize) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID, \ - "uw", \ - debugReportId, \ - debugReportSize); - +#define emberAfFillCommandSlWwahClusterNewDebugReportNotification(debugReportId, debugReportSize) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID, "uw", debugReportId, debugReportSize); /** @brief Command description for SlDebugReportQueryResponse * @@ -14198,20 +8872,11 @@ * @param debugReportData uint8_t* * @param debugReportDataLen uint16_t */ -#define emberAfFillCommandSlWwahClusterDebugReportQueryResponse(debugReportId, \ - debugReportData, \ - debugReportDataLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID, \ - "ub", \ - debugReportId, \ - debugReportData, \ - debugReportDataLen); - +#define emberAfFillCommandSlWwahClusterDebugReportQueryResponse(debugReportId, debugReportData, debugReportDataLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID, "ub", debugReportId, debugReportData, \ + debugReportDataLen); /** @brief Command description for SlTrustCenterForClusterServerQueryResponse * @@ -14221,20 +8886,11 @@ * @param clusterId uint8_t* * @param clusterIdLen uint16_t */ -#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQueryResponse(numberOfClusters, \ - clusterId, \ - clusterIdLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_RESPONSE_COMMAND_ID, \ - "ub", \ - numberOfClusters, \ - clusterId, \ - clusterIdLen); - +#define emberAfFillCommandSlWwahClusterTrustCenterForClusterServerQueryResponse(numberOfClusters, clusterId, clusterIdLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_RESPONSE_COMMAND_ID, "ub", numberOfClusters, \ + clusterId, clusterIdLen); /** @brief Command description for SlSurveyBeaconsResponse * @@ -14244,20 +8900,10 @@ * @param beacon uint8_t* * @param beaconLen uint16_t */ -#define emberAfFillCommandSlWwahClusterSurveyBeaconsResponse(numberOfBeacons, \ - beacon, \ - beaconLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID, \ - "ub", \ - numberOfBeacons, \ - beacon, \ - beaconLen); - +#define emberAfFillCommandSlWwahClusterSurveyBeaconsResponse(numberOfBeacons, beacon, beaconLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID, "ub", numberOfBeacons, beacon, beaconLen); /** @brief Command description for SlUseTrustCenterForClusterServerResponse * @@ -14268,28 +8914,14 @@ * @param clusterStatus uint8_t* * @param clusterStatusLen uint16_t */ -#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServerResponse(status, \ - clusterStatusLength, \ - clusterStatus, \ - clusterStatusLen) \ - emberAfFillExternalManufacturerSpecificBuffer((ZCL_CLUSTER_SPECIFIC_COMMAND \ - | ZCL_MANUFACTURER_SPECIFIC_MASK \ - | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ - ZCL_SL_WWAH_CLUSTER_ID, \ - 0x1217, \ - ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID, \ - "uub", \ - status, \ - clusterStatusLength, \ - clusterStatus, \ - clusterStatusLen); - +#define emberAfFillCommandSlWwahClusterUseTrustCenterForClusterServerResponse(status, clusterStatusLength, clusterStatus, \ + clusterStatusLen) \ + emberAfFillExternalManufacturerSpecificBuffer( \ + (ZCL_CLUSTER_SPECIFIC_COMMAND | ZCL_MANUFACTURER_SPECIFIC_MASK | ZCL_FRAME_CONTROL_SERVER_TO_CLIENT), \ + ZCL_SL_WWAH_CLUSTER_ID, 0x1217, ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID, "uub", status, \ + clusterStatusLength, clusterStatus, clusterStatusLen); /** @} END SL Works With All Hubs Commands */ - - - - /** @} END addtogroup */ #endif // SILABS_CLUSTER_CLIENT_API diff --git a/examples/wifi-echo/server/esp32/main/gen/cluster-id.h b/examples/wifi-echo/server/esp32/main/gen/cluster-id.h index 40e068f8b32465..7462d4e9cf279b 100644 --- a/examples/wifi-echo/server/esp32/main/gen/cluster-id.h +++ b/examples/wifi-echo/server/esp32/main/gen/cluster-id.h @@ -39,7 +39,6 @@ #ifndef SILABS_EMBER_AF_CLUSTER_ID #define SILABS_EMBER_AF_CLUSTER_ID - // Cluster domain specification levels: // * General: zcl-7.0-07-5123-07 // * Lighting & Occupancy: l&o-1.0-15-0014-04 @@ -63,113 +62,113 @@ // * LO: UNKNOWN // * Works With All Hubs: UNKNOWN // * WWAH: UNKNOWN -#define ZCL_BASIC_CLUSTER_ID 0x0000 -#define ZCL_POWER_CONFIG_CLUSTER_ID 0x0001 -#define ZCL_DEVICE_TEMP_CLUSTER_ID 0x0002 -#define ZCL_IDENTIFY_CLUSTER_ID 0x0003 -#define ZCL_GROUPS_CLUSTER_ID 0x0004 -#define ZCL_SCENES_CLUSTER_ID 0x0005 -#define ZCL_ON_OFF_CLUSTER_ID 0x0006 -#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID 0x0007 -#define ZCL_LEVEL_CONTROL_CLUSTER_ID 0x0008 -#define ZCL_ALARM_CLUSTER_ID 0x0009 -#define ZCL_TIME_CLUSTER_ID 0x000A -#define ZCL_RSSI_LOCATION_CLUSTER_ID 0x000B -#define ZCL_BINARY_INPUT_BASIC_CLUSTER_ID 0x000F -#define ZCL_COMMISSIONING_CLUSTER_ID 0x0015 -#define ZCL_PARTITION_CLUSTER_ID 0x0016 -#define ZCL_OTA_BOOTLOAD_CLUSTER_ID 0x0019 -#define ZCL_POWER_PROFILE_CLUSTER_ID 0x001A -#define ZCL_APPLIANCE_CONTROL_CLUSTER_ID 0x001B -#define ZCL_POLL_CONTROL_CLUSTER_ID 0x0020 -#define ZCL_GREEN_POWER_CLUSTER_ID 0x0021 -#define ZCL_KEEPALIVE_CLUSTER_ID 0x0025 -#define ZCL_SHADE_CONFIG_CLUSTER_ID 0x0100 -#define ZCL_DOOR_LOCK_CLUSTER_ID 0x0101 -#define ZCL_WINDOW_COVERING_CLUSTER_ID 0x0102 -#define ZCL_BARRIER_CONTROL_CLUSTER_ID 0x0103 -#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID 0x0200 -#define ZCL_THERMOSTAT_CLUSTER_ID 0x0201 -#define ZCL_FAN_CONTROL_CLUSTER_ID 0x0202 -#define ZCL_DEHUMID_CONTROL_CLUSTER_ID 0x0203 -#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID 0x0204 -#define ZCL_COLOR_CONTROL_CLUSTER_ID 0x0300 -#define ZCL_BALLAST_CONFIGURATION_CLUSTER_ID 0x0301 -#define ZCL_ILLUM_MEASUREMENT_CLUSTER_ID 0x0400 -#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID 0x0401 -#define ZCL_TEMP_MEASUREMENT_CLUSTER_ID 0x0402 -#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID 0x0403 -#define ZCL_FLOW_MEASUREMENT_CLUSTER_ID 0x0404 -#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID 0x0405 -#define ZCL_OCCUPANCY_SENSING_CLUSTER_ID 0x0406 -#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040C -#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040D -#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040E -#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040F -#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0410 -#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0411 -#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0412 -#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0413 -#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0414 -#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0415 -#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0416 -#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0417 -#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0418 -#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0419 -#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041A +#define ZCL_BASIC_CLUSTER_ID 0x0000 +#define ZCL_POWER_CONFIG_CLUSTER_ID 0x0001 +#define ZCL_DEVICE_TEMP_CLUSTER_ID 0x0002 +#define ZCL_IDENTIFY_CLUSTER_ID 0x0003 +#define ZCL_GROUPS_CLUSTER_ID 0x0004 +#define ZCL_SCENES_CLUSTER_ID 0x0005 +#define ZCL_ON_OFF_CLUSTER_ID 0x0006 +#define ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID 0x0007 +#define ZCL_LEVEL_CONTROL_CLUSTER_ID 0x0008 +#define ZCL_ALARM_CLUSTER_ID 0x0009 +#define ZCL_TIME_CLUSTER_ID 0x000A +#define ZCL_RSSI_LOCATION_CLUSTER_ID 0x000B +#define ZCL_BINARY_INPUT_BASIC_CLUSTER_ID 0x000F +#define ZCL_COMMISSIONING_CLUSTER_ID 0x0015 +#define ZCL_PARTITION_CLUSTER_ID 0x0016 +#define ZCL_OTA_BOOTLOAD_CLUSTER_ID 0x0019 +#define ZCL_POWER_PROFILE_CLUSTER_ID 0x001A +#define ZCL_APPLIANCE_CONTROL_CLUSTER_ID 0x001B +#define ZCL_POLL_CONTROL_CLUSTER_ID 0x0020 +#define ZCL_GREEN_POWER_CLUSTER_ID 0x0021 +#define ZCL_KEEPALIVE_CLUSTER_ID 0x0025 +#define ZCL_SHADE_CONFIG_CLUSTER_ID 0x0100 +#define ZCL_DOOR_LOCK_CLUSTER_ID 0x0101 +#define ZCL_WINDOW_COVERING_CLUSTER_ID 0x0102 +#define ZCL_BARRIER_CONTROL_CLUSTER_ID 0x0103 +#define ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID 0x0200 +#define ZCL_THERMOSTAT_CLUSTER_ID 0x0201 +#define ZCL_FAN_CONTROL_CLUSTER_ID 0x0202 +#define ZCL_DEHUMID_CONTROL_CLUSTER_ID 0x0203 +#define ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID 0x0204 +#define ZCL_COLOR_CONTROL_CLUSTER_ID 0x0300 +#define ZCL_BALLAST_CONFIGURATION_CLUSTER_ID 0x0301 +#define ZCL_ILLUM_MEASUREMENT_CLUSTER_ID 0x0400 +#define ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID 0x0401 +#define ZCL_TEMP_MEASUREMENT_CLUSTER_ID 0x0402 +#define ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID 0x0403 +#define ZCL_FLOW_MEASUREMENT_CLUSTER_ID 0x0404 +#define ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID 0x0405 +#define ZCL_OCCUPANCY_SENSING_CLUSTER_ID 0x0406 +#define ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040C +#define ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040D +#define ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040E +#define ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x040F +#define ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0410 +#define ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0411 +#define ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0412 +#define ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0413 +#define ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0414 +#define ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0415 +#define ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0416 +#define ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0417 +#define ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0418 +#define ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0419 +#define ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041A #define ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041B -#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041C -#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041D -#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041E -#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041F -#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0420 -#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0421 -#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0422 -#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0423 -#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0424 -#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0425 -#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0426 -#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0427 -#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0428 -#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0429 -#define ZCL_IAS_ZONE_CLUSTER_ID 0x0500 -#define ZCL_IAS_ACE_CLUSTER_ID 0x0501 -#define ZCL_IAS_WD_CLUSTER_ID 0x0502 -#define ZCL_GENERIC_TUNNEL_CLUSTER_ID 0x0600 -#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID 0x0601 -#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID 0x0614 -#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID 0x0615 -#define ZCL_PRICE_CLUSTER_ID 0x0700 -#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID 0x0701 -#define ZCL_SIMPLE_METERING_CLUSTER_ID 0x0702 -#define ZCL_MESSAGING_CLUSTER_ID 0x0703 -#define ZCL_TUNNELING_CLUSTER_ID 0x0704 -#define ZCL_PREPAYMENT_CLUSTER_ID 0x0705 -#define ZCL_ENERGY_MANAGEMENT_CLUSTER_ID 0x0706 -#define ZCL_CALENDAR_CLUSTER_ID 0x0707 -#define ZCL_DEVICE_MANAGEMENT_CLUSTER_ID 0x0708 -#define ZCL_EVENTS_CLUSTER_ID 0x0709 -#define ZCL_MDU_PAIRING_CLUSTER_ID 0x070A -#define ZCL_SUB_GHZ_CLUSTER_ID 0x070B -#define ZCL_KEY_ESTABLISHMENT_CLUSTER_ID 0x0800 -#define ZCL_INFORMATION_CLUSTER_ID 0x0900 -#define ZCL_DATA_SHARING_CLUSTER_ID 0x0901 -#define ZCL_GAMING_CLUSTER_ID 0x0902 -#define ZCL_DATA_RATE_CONTROL_CLUSTER_ID 0x0903 -#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID 0x0904 -#define ZCL_CHATTING_CLUSTER_ID 0x0905 -#define ZCL_PAYMENT_CLUSTER_ID 0x0A01 -#define ZCL_BILLING_CLUSTER_ID 0x0A02 -#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID 0x0B00 -#define ZCL_METER_IDENTIFICATION_CLUSTER_ID 0x0B01 -#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID 0x0B02 -#define ZCL_APPLIANCE_STATISTICS_CLUSTER_ID 0x0B03 -#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID 0x0B04 -#define ZCL_DIAGNOSTICS_CLUSTER_ID 0x0B05 -#define ZCL_ZLL_COMMISSIONING_CLUSTER_ID 0x1000 -#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID 0xFC00 -#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID 0xFC00 -#define ZCL_OTA_CONFIGURATION_CLUSTER_ID 0xFC01 -#define ZCL_MFGLIB_CLUSTER_ID 0xFC02 -#define ZCL_SL_WWAH_CLUSTER_ID 0xFC57 +#define ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041C +#define ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041D +#define ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041E +#define ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x041F +#define ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0420 +#define ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0421 +#define ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0422 +#define ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0423 +#define ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0424 +#define ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0425 +#define ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0426 +#define ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0427 +#define ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0428 +#define ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID 0x0429 +#define ZCL_IAS_ZONE_CLUSTER_ID 0x0500 +#define ZCL_IAS_ACE_CLUSTER_ID 0x0501 +#define ZCL_IAS_WD_CLUSTER_ID 0x0502 +#define ZCL_GENERIC_TUNNEL_CLUSTER_ID 0x0600 +#define ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID 0x0601 +#define ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID 0x0614 +#define ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID 0x0615 +#define ZCL_PRICE_CLUSTER_ID 0x0700 +#define ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID 0x0701 +#define ZCL_SIMPLE_METERING_CLUSTER_ID 0x0702 +#define ZCL_MESSAGING_CLUSTER_ID 0x0703 +#define ZCL_TUNNELING_CLUSTER_ID 0x0704 +#define ZCL_PREPAYMENT_CLUSTER_ID 0x0705 +#define ZCL_ENERGY_MANAGEMENT_CLUSTER_ID 0x0706 +#define ZCL_CALENDAR_CLUSTER_ID 0x0707 +#define ZCL_DEVICE_MANAGEMENT_CLUSTER_ID 0x0708 +#define ZCL_EVENTS_CLUSTER_ID 0x0709 +#define ZCL_MDU_PAIRING_CLUSTER_ID 0x070A +#define ZCL_SUB_GHZ_CLUSTER_ID 0x070B +#define ZCL_KEY_ESTABLISHMENT_CLUSTER_ID 0x0800 +#define ZCL_INFORMATION_CLUSTER_ID 0x0900 +#define ZCL_DATA_SHARING_CLUSTER_ID 0x0901 +#define ZCL_GAMING_CLUSTER_ID 0x0902 +#define ZCL_DATA_RATE_CONTROL_CLUSTER_ID 0x0903 +#define ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID 0x0904 +#define ZCL_CHATTING_CLUSTER_ID 0x0905 +#define ZCL_PAYMENT_CLUSTER_ID 0x0A01 +#define ZCL_BILLING_CLUSTER_ID 0x0A02 +#define ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID 0x0B00 +#define ZCL_METER_IDENTIFICATION_CLUSTER_ID 0x0B01 +#define ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID 0x0B02 +#define ZCL_APPLIANCE_STATISTICS_CLUSTER_ID 0x0B03 +#define ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID 0x0B04 +#define ZCL_DIAGNOSTICS_CLUSTER_ID 0x0B05 +#define ZCL_ZLL_COMMISSIONING_CLUSTER_ID 0x1000 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID 0xFC00 +#define ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID 0xFC00 +#define ZCL_OTA_CONFIGURATION_CLUSTER_ID 0xFC01 +#define ZCL_MFGLIB_CLUSTER_ID 0xFC02 +#define ZCL_SL_WWAH_CLUSTER_ID 0xFC57 #endif // SILABS_EMBER_AF_CLUSTER_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/command-id.h b/examples/wifi-echo/server/esp32/main/gen/command-id.h index 18812dda04aa23..823914d0466035 100644 --- a/examples/wifi-echo/server/esp32/main/gen/command-id.h +++ b/examples/wifi-echo/server/esp32/main/gen/command-id.h @@ -39,32 +39,31 @@ #ifndef SILABS_EMBER_AF_COMMAND_ID #define SILABS_EMBER_AF_COMMAND_ID - // Global commands // Either direction -#define ZCL_READ_ATTRIBUTES_COMMAND_ID 0x00 // Ver.: always -#define ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_COMMAND_ID 0x02 // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID 0x03 // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_CONFIGURE_REPORTING_COMMAND_ID 0x06 // Ver.: always -#define ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID 0x07 // Ver.: always -#define ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID 0x08 // Ver.: always +#define ZCL_READ_ATTRIBUTES_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_COMMAND_ID 0x02 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_CONFIGURE_REPORTING_COMMAND_ID 0x06 // Ver.: always +#define ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID 0x08 // Ver.: always #define ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID 0x09 // Ver.: always -#define ZCL_REPORT_ATTRIBUTES_COMMAND_ID 0x0A // Ver.: always -#define ZCL_DEFAULT_RESPONSE_COMMAND_ID 0x0B // Ver.: always -#define ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID 0x0C // Ver.: always -#define ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID 0x0D // Ver.: always -#define ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0E // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0F // Ver.: always -#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID 0x10 // Ver.: always -#define ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID 0x11 // Ver.: always -#define ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID 0x12 // Ver.: always -#define ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID 0x13 // Ver.: always -#define ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID 0x14 // Ver.: always -#define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID 0x15 // Ver.: always +#define ZCL_REPORT_ATTRIBUTES_COMMAND_ID 0x0A // Ver.: always +#define ZCL_DEFAULT_RESPONSE_COMMAND_ID 0x0B // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID 0x0C // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID 0x0D // Ver.: always +#define ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0E // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID 0x0F // Ver.: always +#define ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID 0x10 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID 0x11 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID 0x12 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID 0x13 // Ver.: always +#define ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID 0x14 // Ver.: always +#define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID 0x15 // Ver.: always #define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID 0x16 // Ver.: always // Command types for cluster: Basic // Cluster specification level: zcl-7.0-07-5123-07 @@ -74,8 +73,7 @@ // Client to server #define ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID 0x01 // Ver.: always - +#define ZCL_GET_LOCALES_SUPPORTED_COMMAND_ID 0x01 // Ver.: always // Command types for cluster: Identify // Cluster specification level: zcl-7.0-07-5123-07 @@ -84,217 +82,205 @@ #define ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID 0x00 // Ver.: always // Client to server -#define ZCL_IDENTIFY_COMMAND_ID 0x00 // Ver.: always -#define ZCL_IDENTIFY_QUERY_COMMAND_ID 0x01 // Ver.: always -#define ZCL_E_Z_MODE_INVOKE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_IDENTIFY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_IDENTIFY_QUERY_COMMAND_ID 0x01 // Ver.: always +#define ZCL_E_Z_MODE_INVOKE_COMMAND_ID 0x02 // Ver.: always #define ZCL_UPDATE_COMMISSION_STATE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_TRIGGER_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 - +#define ZCL_TRIGGER_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 // Command types for cluster: Groups // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_ADD_GROUP_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_ADD_GROUP_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID 0x01 // Ver.: always #define ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID 0x03 // Ver.: always // Client to server -#define ZCL_ADD_GROUP_COMMAND_ID 0x00 // Ver.: always -#define ZCL_VIEW_GROUP_COMMAND_ID 0x01 // Ver.: always -#define ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REMOVE_GROUP_COMMAND_ID 0x03 // Ver.: always -#define ZCL_REMOVE_ALL_GROUPS_COMMAND_ID 0x04 // Ver.: always +#define ZCL_ADD_GROUP_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_GROUP_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_GROUP_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REMOVE_ALL_GROUPS_COMMAND_ID 0x04 // Ver.: always #define ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID 0x05 // Ver.: always - // Command types for cluster: Scenes // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_ADD_SCENE_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_STORE_SCENE_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_ADD_SCENE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_STORE_SCENE_RESPONSE_COMMAND_ID 0x04 // Ver.: always #define ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID 0x06 // Ver.: always -#define ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COPY_SCENE_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_ADD_SCENE_RESPONSE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_VIEW_SCENE_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COPY_SCENE_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 // Client to server -#define ZCL_ADD_SCENE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_VIEW_SCENE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_REMOVE_SCENE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REMOVE_ALL_SCENES_COMMAND_ID 0x03 // Ver.: always -#define ZCL_STORE_SCENE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_RECALL_SCENE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_ADD_SCENE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VIEW_SCENE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_SCENE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REMOVE_ALL_SCENES_COMMAND_ID 0x03 // Ver.: always +#define ZCL_STORE_SCENE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_RECALL_SCENE_COMMAND_ID 0x05 // Ver.: always #define ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID 0x06 // Ver.: always -#define ZCL_ENHANCED_ADD_SCENE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COPY_SCENE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 - +#define ZCL_ENHANCED_ADD_SCENE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_VIEW_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_COPY_SCENE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 // Command types for cluster: On/off // Cluster specification level: zcl-7.0-07-5123-07 // Client to server -#define ZCL_OFF_COMMAND_ID 0x00 // Ver.: always -#define ZCL_ON_COMMAND_ID 0x01 // Ver.: always -#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_OFF_WITH_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ON_WITH_TIMED_OFF_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 -#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 -#define ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 -#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1049 +#define ZCL_OFF_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ON_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_OFF_WITH_EFFECT_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_WITH_RECALL_GLOBAL_SCENE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ON_WITH_TIMED_OFF_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_SAMPLE_MFG_SPECIFIC_OFF_WITH_TRANSITION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 +#define ZCL_SAMPLE_MFG_SPECIFIC_ON_WITH_TRANSITION2_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1049 #define ZCL_SAMPLE_MFG_SPECIFIC_TOGGLE_WITH_TRANSITION2_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1049 - // Command types for cluster: Level Control // Cluster specification level: zcl-7.0-07-5123-07 // Client to server -#define ZCL_MOVE_TO_LEVEL_COMMAND_ID 0x00 // Ver.: always -#define ZCL_MOVE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_STEP_COMMAND_ID 0x02 // Ver.: always -#define ZCL_STOP_COMMAND_ID 0x03 // Ver.: always +#define ZCL_MOVE_TO_LEVEL_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MOVE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_STEP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_STOP_COMMAND_ID 0x03 // Ver.: always #define ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID 0x04 // Ver.: always -#define ZCL_MOVE_WITH_ON_OFF_COMMAND_ID 0x05 // Ver.: always -#define ZCL_STEP_WITH_ON_OFF_COMMAND_ID 0x06 // Ver.: always -#define ZCL_STOP_WITH_ON_OFF_COMMAND_ID 0x07 // Ver.: always - +#define ZCL_MOVE_WITH_ON_OFF_COMMAND_ID 0x05 // Ver.: always +#define ZCL_STEP_WITH_ON_OFF_COMMAND_ID 0x06 // Ver.: always +#define ZCL_STOP_WITH_ON_OFF_COMMAND_ID 0x07 // Ver.: always // Command types for cluster: Alarms // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_ALARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ALARM_COMMAND_ID 0x00 // Ver.: always #define ZCL_GET_ALARM_RESPONSE_COMMAND_ID 0x01 // Ver.: always // Client to server -#define ZCL_RESET_ALARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_RESET_ALARM_COMMAND_ID 0x00 // Ver.: always #define ZCL_RESET_ALL_ALARMS_COMMAND_ID 0x01 // Ver.: always -#define ZCL_GET_ALARM_COMMAND_ID 0x02 // Ver.: always -#define ZCL_RESET_ALARM_LOG_COMMAND_ID 0x03 // Ver.: always - +#define ZCL_GET_ALARM_COMMAND_ID 0x02 // Ver.: always +#define ZCL_RESET_ALARM_LOG_COMMAND_ID 0x03 // Ver.: always // Command types for cluster: RSSI Location // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_DEVICE_CONFIGURATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOCATION_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_LOCATION_DATA_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always #define ZCL_COMPACT_LOCATION_DATA_NOTIFICATION_COMMAND_ID 0x03 // Ver.: always -#define ZCL_RSSI_PING_COMMAND_ID 0x04 // Ver.: always -#define ZCL_RSSI_REQUEST_COMMAND_ID 0x05 // Ver.: always -#define ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID 0x06 // Ver.: always -#define ZCL_REQUEST_OWN_LOCATION_COMMAND_ID 0x07 // Ver.: always +#define ZCL_RSSI_PING_COMMAND_ID 0x04 // Ver.: always +#define ZCL_RSSI_REQUEST_COMMAND_ID 0x05 // Ver.: always +#define ZCL_REPORT_RSSI_MEASUREMENTS_COMMAND_ID 0x06 // Ver.: always +#define ZCL_REQUEST_OWN_LOCATION_COMMAND_ID 0x07 // Ver.: always // Client to server -#define ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SET_ABSOLUTE_LOCATION_COMMAND_ID 0x00 // Ver.: always #define ZCL_SET_DEVICE_CONFIGURATION_COMMAND_ID 0x01 // Ver.: always #define ZCL_GET_DEVICE_CONFIGURATION_COMMAND_ID 0x02 // Ver.: always -#define ZCL_GET_LOCATION_DATA_COMMAND_ID 0x03 // Ver.: always -#define ZCL_RSSI_RESPONSE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_SEND_PINGS_COMMAND_ID 0x05 // Ver.: always -#define ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID 0x06 // Ver.: always - +#define ZCL_GET_LOCATION_DATA_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RSSI_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SEND_PINGS_COMMAND_ID 0x05 // Ver.: always +#define ZCL_ANCHOR_NODE_ANNOUNCE_COMMAND_ID 0x06 // Ver.: always // Command types for cluster: Commissioning // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_RESTART_DEVICE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SAVE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x01 // Ver.: always #define ZCL_RESTORE_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RESET_STARTUP_PARAMETERS_RESPONSE_COMMAND_ID 0x03 // Ver.: always // Client to server -#define ZCL_RESTART_DEVICE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_RESTART_DEVICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SAVE_STARTUP_PARAMETERS_COMMAND_ID 0x01 // Ver.: always #define ZCL_RESTORE_STARTUP_PARAMETERS_COMMAND_ID 0x02 // Ver.: always -#define ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID 0x03 // Ver.: always - +#define ZCL_RESET_STARTUP_PARAMETERS_COMMAND_ID 0x03 // Ver.: always // Command types for cluster: Partition // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_MULTIPLE_ACK_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MULTIPLE_ACK_COMMAND_ID 0x00 // Ver.: always #define ZCL_READ_HANDSHAKE_PARAM_RESPONSE_COMMAND_ID 0x01 // Ver.: always // Client to server #define ZCL_TRANSFER_PARTITIONED_FRAME_COMMAND_ID 0x00 // Ver.: always -#define ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID 0x01 // Ver.: always -#define ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID 0x02 // Ver.: always - +#define ZCL_READ_HANDSHAKE_PARAM_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_HANDSHAKE_PARAM_COMMAND_ID 0x02 // Ver.: always // Command types for cluster: Over the Air Bootloading // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_IMAGE_NOTIFY_COMMAND_ID 0x00 // Ver.: always -#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_UPGRADE_END_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_IMAGE_NOTIFY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_IMAGE_BLOCK_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_UPGRADE_END_RESPONSE_COMMAND_ID 0x07 // Ver.: always #define ZCL_QUERY_SPECIFIC_FILE_RESPONSE_COMMAND_ID 0x09 // Ver.: always // Client to server -#define ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID 0x01 // Ver.: always -#define ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID 0x03 // Ver.: always -#define ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID 0x04 // Ver.: always -#define ZCL_UPGRADE_END_REQUEST_COMMAND_ID 0x06 // Ver.: always +#define ZCL_QUERY_NEXT_IMAGE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_IMAGE_BLOCK_REQUEST_COMMAND_ID 0x03 // Ver.: always +#define ZCL_IMAGE_PAGE_REQUEST_COMMAND_ID 0x04 // Ver.: always +#define ZCL_UPGRADE_END_REQUEST_COMMAND_ID 0x06 // Ver.: always #define ZCL_QUERY_SPECIFIC_FILE_REQUEST_COMMAND_ID 0x08 // Ver.: always - // Command types for cluster: Power Profile // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always -#define ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID 0x06 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID 0x07 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID 0x08 // Ver.: always +#define ZCL_POWER_PROFILE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_POWER_PROFILE_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_POWER_PROFILE_STATE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_POWER_PROFILES_STATE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_OVERALL_SCHEDULE_PRICE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_REQUEST_COMMAND_ID 0x06 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_RESPONSE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_NOTIFICATION_COMMAND_ID 0x08 // Ver.: always #define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_NOTIFICATION_COMMAND_ID 0x09 // Ver.: always -#define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID 0x0A // Ver.: always -#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID 0x0B // Ver.: always +#define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_RESPONSE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_COMMAND_ID 0x0B // Ver.: always // Client to server -#define ZCL_POWER_PROFILE_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID 0x01 // Ver.: always -#define ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_POWER_PROFILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_POWER_PROFILE_STATE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_OVERALL_SCHEDULE_PRICE_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_ENERGY_PHASES_SCHEDULE_RESPONSE_COMMAND_ID 0x05 // Ver.: always #define ZCL_POWER_PROFILE_SCHEDULE_CONSTRAINTS_REQUEST_COMMAND_ID 0x06 // Ver.: always -#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID 0x07 // Ver.: always -#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID 0x08 // Ver.: always - +#define ZCL_ENERGY_PHASES_SCHEDULE_STATE_REQUEST_COMMAND_ID 0x07 // Ver.: always +#define ZCL_GET_POWER_PROFILE_PRICE_EXTENDED_RESPONSE_COMMAND_ID 0x08 // Ver.: always // Command types for cluster: Appliance Control // Cluster specification level: zcl-7.0-07-5123-07 // Server to client -#define ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SIGNAL_STATE_RESPONSE_COMMAND_ID 0x00 // Ver.: always #define ZCL_SIGNAL_STATE_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always // Client to server #define ZCL_EXECUTION_OF_A_COMMAND_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SIGNAL_STATE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_WRITE_FUNCTIONS_COMMAND_ID 0x02 // Ver.: always -#define ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID 0x03 // Ver.: always -#define ZCL_OVERLOAD_PAUSE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_OVERLOAD_WARNING_COMMAND_ID 0x05 // Ver.: always - +#define ZCL_SIGNAL_STATE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_FUNCTIONS_COMMAND_ID 0x02 // Ver.: always +#define ZCL_OVERLOAD_PAUSE_RESUME_COMMAND_ID 0x03 // Ver.: always +#define ZCL_OVERLOAD_PAUSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_OVERLOAD_WARNING_COMMAND_ID 0x05 // Ver.: always // Command types for cluster: Poll Control // Cluster specification level: zcl-7.0-07-5123-07 @@ -303,400 +289,380 @@ #define ZCL_CHECK_IN_COMMAND_ID 0x00 // Ver.: always // Client to server -#define ZCL_CHECK_IN_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_FAST_POLL_STOP_COMMAND_ID 0x01 // Ver.: always -#define ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID 0x02 // Ver.: always +#define ZCL_CHECK_IN_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_FAST_POLL_STOP_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SET_LONG_POLL_INTERVAL_COMMAND_ID 0x02 // Ver.: always #define ZCL_SET_SHORT_POLL_INTERVAL_COMMAND_ID 0x03 // Ver.: always - // Command types for cluster: Green Power // Cluster specification level: gp-1.0a-09-5499-26 // Server to client -#define ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_PAIRING_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID 0x02 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_RESPONSE_COMMAND_ID 0x06 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_NOTIFICATION_RESPONSE_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PAIRING_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PROXY_COMMISSIONING_MODE_COMMAND_ID 0x02 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_RESPONSE_COMMAND_ID 0x06 // Ver.: since gp-1.0-09-5499-24 #define ZCL_GP_TRANSLATION_TABLE_RESPONSE_COMMAND_ID 0x08 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID 0x0A // Ver.: always -#define ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID 0x0B // Ver.: always +#define ZCL_GP_SINK_TABLE_RESPONSE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GP_PROXY_TABLE_REQUEST_COMMAND_ID 0x0B // Ver.: always // Client to server -#define ZCL_GP_NOTIFICATION_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_PAIRING_SEARCH_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_TUNNELING_STOP_COMMAND_ID 0x03 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_NOTIFICATION_COMMAND_ID 0x00 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_PAIRING_SEARCH_COMMAND_ID 0x01 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_TUNNELING_STOP_COMMAND_ID 0x03 // Ver.: since gp-1.0-09-5499-24 #define ZCL_GP_COMMISSIONING_NOTIFICATION_COMMAND_ID 0x04 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID 0x07 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID 0x08 // Ver.: always -#define ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID 0x09 // Ver.: since gp-1.0-09-5499-24 -#define ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID 0x0A // Ver.: always -#define ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID 0x0B // Ver.: always - +#define ZCL_GP_SINK_COMMISSIONING_MODE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GP_TRANSLATION_TABLE_UPDATE_COMMAND_ID 0x07 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_TRANSLATION_TABLE_REQUEST_COMMAND_ID 0x08 // Ver.: always +#define ZCL_GP_PAIRING_CONFIGURATION_COMMAND_ID 0x09 // Ver.: since gp-1.0-09-5499-24 +#define ZCL_GP_SINK_TABLE_REQUEST_COMMAND_ID 0x0A // Ver.: always +#define ZCL_GP_PROXY_TABLE_RESPONSE_COMMAND_ID 0x0B // Ver.: always // Command types for cluster: Door Lock // Cluster specification level: zcl-6.0-15-02018-001 // Server to client -#define ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_TOGGLE_RESPONSE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_PIN_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_PIN_RESPONSE_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_RESPONSE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_PIN_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_PIN_RESPONSE_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_STATUS_RESPONSE_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_STATUS_RESPONSE_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0D // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x10 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID 0x13 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_RFID_RESPONSE_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_RFID_RESPONSE_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID 0x20 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID 0x21 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_RFID_RESPONSE_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_RFID_RESPONSE_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_OPERATION_EVENT_NOTIFICATION_COMMAND_ID 0x20 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_PROGRAMMING_EVENT_NOTIFICATION_COMMAND_ID 0x21 // Ver.: since ha-1.2-05-3520-29 // Client to server -#define ZCL_LOCK_DOOR_COMMAND_ID 0x00 // Ver.: always -#define ZCL_UNLOCK_DOOR_COMMAND_ID 0x01 // Ver.: always -#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_LOG_RECORD_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_PIN_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_PIN_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_PIN_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_ALL_PINS_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_USER_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_USER_STATUS_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 +#define ZCL_LOCK_DOOR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNLOCK_DOOR_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TOGGLE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_LOG_RECORD_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_PIN_COMMAND_ID 0x05 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_PIN_COMMAND_ID 0x06 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_PIN_COMMAND_ID 0x07 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_PINS_COMMAND_ID 0x08 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_USER_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_STATUS_COMMAND_ID 0x0A // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0B // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID 0x0C // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID 0x0D // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID 0x0E // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID 0x0F // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID 0x10 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID 0x11 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID 0x12 // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID 0x13 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_USER_TYPE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_USER_TYPE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_SET_RFID_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_RFID_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_RFID_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_CLEAR_ALL_RFIDS_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 - +#define ZCL_SET_USER_TYPE_COMMAND_ID 0x14 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_USER_TYPE_COMMAND_ID 0x15 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SET_RFID_COMMAND_ID 0x16 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_RFID_COMMAND_ID 0x17 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_RFID_COMMAND_ID 0x18 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_CLEAR_ALL_RFIDS_COMMAND_ID 0x19 // Ver.: since ha-1.2-05-3520-29 // Command types for cluster: Window Covering // Cluster specification level: zcl-6.0-15-02018-001 // Client to server -#define ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID 0x00 // Ver.: always -#define ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_WINDOW_COVERING_STOP_COMMAND_ID 0x02 // Ver.: always -#define ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_WINDOW_COVERING_UP_OPEN_COMMAND_ID 0x00 // Ver.: always +#define ZCL_WINDOW_COVERING_DOWN_CLOSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WINDOW_COVERING_STOP_COMMAND_ID 0x02 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_LIFT_VALUE_COMMAND_ID 0x04 // Ver.: always #define ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_WINDOW_COVERING_GO_TO_TILT_VALUE_COMMAND_ID 0x07 // Ver.: always #define ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_COMMAND_ID 0x08 // Ver.: always - // Command types for cluster: Barrier Control // Cluster specification level: zcl-6.0-15-02018-001 // Client to server #define ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID 0x00 // Ver.: always -#define ZCL_BARRIER_CONTROL_STOP_COMMAND_ID 0x01 // Ver.: always - +#define ZCL_BARRIER_CONTROL_STOP_COMMAND_ID 0x01 // Ver.: always // Command types for cluster: Thermostat // Cluster specification level: zcl-6.0-15-02018-001 // Server to client #define ZCL_CURRENT_WEEKLY_SCHEDULE_COMMAND_ID 0x00 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_RELAY_STATUS_LOG_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_RELAY_STATUS_LOG_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 // Client to server -#define ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_SETPOINT_RAISE_LOWER_COMMAND_ID 0x00 // Ver.: always +#define ZCL_SET_WEEKLY_SCHEDULE_COMMAND_ID 0x01 // Ver.: since ha-1.2-05-3520-29 +#define ZCL_GET_WEEKLY_SCHEDULE_COMMAND_ID 0x02 // Ver.: since ha-1.2-05-3520-29 #define ZCL_CLEAR_WEEKLY_SCHEDULE_COMMAND_ID 0x03 // Ver.: since ha-1.2-05-3520-29 -#define ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 - +#define ZCL_GET_RELAY_STATUS_LOG_COMMAND_ID 0x04 // Ver.: since ha-1.2-05-3520-29 // Command types for cluster: Color Control // Cluster specification level: zcl6-errata-14-0129-15 // Client to server -#define ZCL_MOVE_TO_HUE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_MOVE_HUE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_STEP_HUE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_MOVE_TO_SATURATION_COMMAND_ID 0x03 // Ver.: always -#define ZCL_MOVE_SATURATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_STEP_SATURATION_COMMAND_ID 0x05 // Ver.: always -#define ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID 0x06 // Ver.: always -#define ZCL_MOVE_TO_COLOR_COMMAND_ID 0x07 // Ver.: always -#define ZCL_MOVE_COLOR_COMMAND_ID 0x08 // Ver.: always -#define ZCL_STEP_COLOR_COMMAND_ID 0x09 // Ver.: always -#define ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID 0x0A // Ver.: always -#define ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ENHANCED_MOVE_HUE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ENHANCED_STEP_HUE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_MOVE_TO_HUE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MOVE_HUE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_STEP_HUE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_MOVE_TO_SATURATION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_MOVE_SATURATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_STEP_SATURATION_COMMAND_ID 0x05 // Ver.: always +#define ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_MOVE_TO_COLOR_COMMAND_ID 0x07 // Ver.: always +#define ZCL_MOVE_COLOR_COMMAND_ID 0x08 // Ver.: always +#define ZCL_STEP_COLOR_COMMAND_ID 0x09 // Ver.: always +#define ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID 0x0A // Ver.: always +#define ZCL_ENHANCED_MOVE_TO_HUE_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_MOVE_HUE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENHANCED_STEP_HUE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 #define ZCL_ENHANCED_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID 0x43 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_COLOR_LOOP_SET_COMMAND_ID 0x44 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_STOP_MOVE_STEP_COMMAND_ID 0x47 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID 0x4B // Ver.: since zll-1.0-11-0037-10 -#define ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID 0x4C // Ver.: since zll-1.0-11-0037-10 - +#define ZCL_COLOR_LOOP_SET_COMMAND_ID 0x44 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_STOP_MOVE_STEP_COMMAND_ID 0x47 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID 0x4B // Ver.: since zll-1.0-11-0037-10 +#define ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID 0x4C // Ver.: since zll-1.0-11-0037-10 // Command types for cluster: IAS Zone // Cluster specification level: zcl-6.0-15-02018-001 // Server to client -#define ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always -#define ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_ZONE_STATUS_CHANGE_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ZONE_ENROLL_REQUEST_COMMAND_ID 0x01 // Ver.: always #define ZCL_INITIATE_NORMAL_OPERATION_MODE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_INITIATE_TEST_MODE_RESPONSE_COMMAND_ID 0x03 // Ver.: always // Client to server -#define ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID 0x00 // Ver.: always #define ZCL_INITIATE_NORMAL_OPERATION_MODE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_INITIATE_TEST_MODE_COMMAND_ID 0x02 // Ver.: always - +#define ZCL_INITIATE_TEST_MODE_COMMAND_ID 0x02 // Ver.: always // Command types for cluster: IAS ACE // Cluster specification level: zcl-6.0-15-02018-001 // Server to client -#define ZCL_ARM_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_ARM_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_ZONE_ID_MAP_RESPONSE_COMMAND_ID 0x01 // Ver.: always #define ZCL_GET_ZONE_INFORMATION_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_ZONE_STATUS_CHANGED_COMMAND_ID 0x03 // Ver.: always -#define ZCL_PANEL_STATUS_CHANGED_COMMAND_ID 0x04 // Ver.: always -#define ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2.1-05-3520-30 -#define ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID 0x06 // Ver.: since ha-1.2.1-05-3520-30 -#define ZCL_BYPASS_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 -#define ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_ZONE_STATUS_CHANGED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PANEL_STATUS_CHANGED_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_PANEL_STATUS_RESPONSE_COMMAND_ID 0x05 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_SET_BYPASSED_ZONE_LIST_COMMAND_ID 0x06 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_BYPASS_RESPONSE_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_GET_ZONE_STATUS_RESPONSE_COMMAND_ID 0x08 // Ver.: since ha-1.2.1-05-3520-30 // Client to server -#define ZCL_ARM_COMMAND_ID 0x00 // Ver.: always -#define ZCL_BYPASS_COMMAND_ID 0x01 // Ver.: always -#define ZCL_EMERGENCY_COMMAND_ID 0x02 // Ver.: always -#define ZCL_FIRE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_PANIC_COMMAND_ID 0x04 // Ver.: always -#define ZCL_GET_ZONE_ID_MAP_COMMAND_ID 0x05 // Ver.: always -#define ZCL_GET_ZONE_INFORMATION_COMMAND_ID 0x06 // Ver.: always -#define ZCL_GET_PANEL_STATUS_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 +#define ZCL_ARM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_BYPASS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_EMERGENCY_COMMAND_ID 0x02 // Ver.: always +#define ZCL_FIRE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PANIC_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_ZONE_ID_MAP_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_ZONE_INFORMATION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_GET_PANEL_STATUS_COMMAND_ID 0x07 // Ver.: since ha-1.2.1-05-3520-30 #define ZCL_GET_BYPASSED_ZONE_LIST_COMMAND_ID 0x08 // Ver.: since ha-1.2.1-05-3520-30 -#define ZCL_GET_ZONE_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2.1-05-3520-30 - +#define ZCL_GET_ZONE_STATUS_COMMAND_ID 0x09 // Ver.: since ha-1.2.1-05-3520-30 // Command types for cluster: IAS WD // Cluster specification level: zcl-6.0-15-02018-001 // Client to server #define ZCL_START_WARNING_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SQUAWK_COMMAND_ID 0x01 // Ver.: always - +#define ZCL_SQUAWK_COMMAND_ID 0x01 // Ver.: always // Command types for cluster: Generic Tunnel // Cluster specification level: cba-1.0-05-3516-12 // Server to client #define ZCL_MATCH_PROTOCOL_ADDRESS_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID 0x01 // Ver.: always +#define ZCL_ADVERTISE_PROTOCOL_ADDRESS_COMMAND_ID 0x01 // Ver.: always // Client to server #define ZCL_MATCH_PROTOCOL_ADDRESS_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: BACnet Protocol Tunnel // Cluster specification level: cba-1.0-05-3516-12 // Client to server #define ZCL_TRANSFER_NPDU_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: 11073 Protocol Tunnel // Cluster specification level: hc-1.0-07-5360-15 // Client to server -#define ZCL_TRANSFER_A_P_D_U_COMMAND_ID 0x00 // Ver.: always -#define ZCL_CONNECT_REQUEST_COMMAND_ID 0x01 // Ver.: always -#define ZCL_DISCONNECT_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_TRANSFER_A_P_D_U_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CONNECT_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_DISCONNECT_REQUEST_COMMAND_ID 0x02 // Ver.: always #define ZCL_CONNECT_STATUS_NOTIFICATION_COMMAND_ID 0x03 // Ver.: always - // Command types for cluster: ISO 7816 Protocol Tunnel // Cluster specification level: ta-1.0-07-5307-07 // Client to server -#define ZCL_INSERT_SMART_CARD_COMMAND_ID 0x01 // Ver.: always +#define ZCL_INSERT_SMART_CARD_COMMAND_ID 0x01 // Ver.: always #define ZCL_EXTRACT_SMART_CARD_COMMAND_ID 0x02 // Ver.: always // Either direction #define ZCL_TRANSFER_APDU_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: Price // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_PUBLISH_PRICE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID 0x01 // Ver.: since se-1.1-07-5356-16 -#define ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID 0x02 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID 0x03 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_TIER_LABELS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_CPP_EVENT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_PRICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_BLOCK_PERIOD_COMMAND_ID 0x01 // Ver.: since se-1.1-07-5356-16 +#define ZCL_PUBLISH_CONVERSION_FACTOR_COMMAND_ID 0x02 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_PUBLISH_CALORIFIC_VALUE_COMMAND_ID 0x03 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_PUBLISH_TARIFF_INFORMATION_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_PRICE_MATRIX_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_BLOCK_THRESHOLDS_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_C_O2_VALUE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_TIER_LABELS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_BILLING_PERIOD_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CONSOLIDATED_BILL_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CPP_EVENT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_CREDIT_PAYMENT_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 #define ZCL_PUBLISH_CURRENCY_CONVERSION_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CANCEL_TARIFF_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CANCEL_TARIFF_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 // Client to server -#define ZCL_GET_CURRENT_PRICE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GET_SCHEDULED_PRICES_COMMAND_ID 0x01 // Ver.: always -#define ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID 0x02 // Ver.: since se-1.1-07-5356-16 -#define ZCL_GET_BLOCK_PERIODS_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 -#define ZCL_GET_CONVERSION_FACTOR_COMMAND_ID 0x04 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_GET_CALORIFIC_VALUE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_GET_TARIFF_INFORMATION_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_PRICE_MATRIX_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_C_O2_VALUE_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_TIER_LABELS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_BILLING_PERIOD_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CPP_EVENT_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_CREDIT_PAYMENT_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CURRENT_PRICE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_SCHEDULED_PRICES_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PRICE_ACKNOWLEDGEMENT_COMMAND_ID 0x02 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GET_BLOCK_PERIODS_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 +#define ZCL_GET_CONVERSION_FACTOR_COMMAND_ID 0x04 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_GET_CALORIFIC_VALUE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_GET_TARIFF_INFORMATION_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_PRICE_MATRIX_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_BLOCK_THRESHOLDS_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_C_O2_VALUE_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_TIER_LABELS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_BILLING_PERIOD_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CONSOLIDATED_BILL_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CPP_EVENT_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_CREDIT_PAYMENT_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 #define ZCL_GET_CURRENCY_CONVERSION_COMMAND_COMMAND_ID 0x0F // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID 0x10 // Ver.: since se-1.2a-07-5356-19 - +#define ZCL_GET_TARIFF_CANCELLATION_COMMAND_ID 0x10 // Ver.: since se-1.2a-07-5356-19 // Command types for cluster: Demand Response and Load Control // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_LOAD_CONTROL_EVENT_COMMAND_ID 0x00 // Ver.: always -#define ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_LOAD_CONTROL_EVENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CANCEL_LOAD_CONTROL_EVENT_COMMAND_ID 0x01 // Ver.: always #define ZCL_CANCEL_ALL_LOAD_CONTROL_EVENTS_COMMAND_ID 0x02 // Ver.: always // Client to server -#define ZCL_REPORT_EVENT_STATUS_COMMAND_ID 0x00 // Ver.: always +#define ZCL_REPORT_EVENT_STATUS_COMMAND_ID 0x00 // Ver.: always #define ZCL_GET_SCHEDULED_EVENTS_COMMAND_ID 0x01 // Ver.: always - // Command types for cluster: Simple Metering // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_GET_PROFILE_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_REQUEST_MIRROR_COMMAND_ID 0x01 // Ver.: always -#define ZCL_REMOVE_MIRROR_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_PROFILE_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_REQUEST_MIRROR_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REMOVE_MIRROR_COMMAND_ID 0x02 // Ver.: always #define ZCL_REQUEST_FAST_POLL_MODE_RESPONSE_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 -#define ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONFIGURE_MIRROR_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_START_SAMPLING_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SCHEDULE_SNAPSHOT_RESPONSE_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TAKE_SNAPSHOT_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SAMPLED_DATA_RESPONSE_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_MIRROR_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_NOTIFICATION_SCHEME_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONFIGURE_NOTIFICATION_FLAGS_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_NOTIFIED_MESSAGE_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SUPPLY_STATUS_RESPONSE_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_SAMPLING_RESPONSE_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 // Client to server -#define ZCL_GET_PROFILE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_MIRROR_REMOVED_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 -#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_TAKE_SNAPSHOT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_START_SAMPLING_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_SAMPLED_DATA_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_PROFILE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_REQUEST_MIRROR_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_MIRROR_REMOVED_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_FAST_POLL_MODE_COMMAND_ID 0x03 // Ver.: since se-1.1-07-5356-16 +#define ZCL_SCHEDULE_SNAPSHOT_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_TAKE_SNAPSHOT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SNAPSHOT_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_START_SAMPLING_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_SAMPLED_DATA_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 #define ZCL_MIRROR_REPORT_ATTRIBUTE_RESPONSE_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CHANGE_SUPPLY_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SET_SUPPLY_STATUS_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 - +#define ZCL_RESET_LOAD_LIMIT_COUNTER_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CHANGE_SUPPLY_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_LOCAL_CHANGE_SUPPLY_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_SUPPLY_STATUS_COMMAND_ID 0x0D // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_UNCONTROLLED_FLOW_THRESHOLD_COMMAND_ID 0x0E // Ver.: since se-1.2a-07-5356-19 // Command types for cluster: Messaging // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_DISPLAY_MESSAGE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_CANCEL_MESSAGE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_DISPLAY_MESSAGE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CANCEL_MESSAGE_COMMAND_ID 0x01 // Ver.: always #define ZCL_DISPLAY_PROTECTED_MESSAGE_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CANCEL_ALL_MESSAGES_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 // Client to server -#define ZCL_GET_LAST_MESSAGE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_MESSAGE_CONFIRMATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_LAST_MESSAGE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MESSAGE_CONFIRMATION_COMMAND_ID 0x01 // Ver.: always #define ZCL_GET_MESSAGE_CANCELLATION_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 - // Command types for cluster: Tunneling // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REQUEST_TUNNEL_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x01 // Ver.: always #define ZCL_TRANSFER_DATA_ERROR_SERVER_TO_CLIENT_COMMAND_ID 0x02 // Ver.: always -#define ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x03 // Ver.: always -#define ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x04 // Ver.: always -#define ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 -#define ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_ACK_TRANSFER_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x03 // Ver.: always +#define ZCL_READY_DATA_SERVER_TO_CLIENT_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SUPPORTED_TUNNEL_PROTOCOLS_RESPONSE_COMMAND_ID 0x05 // Ver.: since se-1.1a-07-5356-17 +#define ZCL_TUNNEL_CLOSURE_NOTIFICATION_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 // Client to server -#define ZCL_REQUEST_TUNNEL_COMMAND_ID 0x00 // Ver.: always -#define ZCL_CLOSE_TUNNEL_COMMAND_ID 0x01 // Ver.: always -#define ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_TUNNEL_COMMAND_ID 0x00 // Ver.: always +#define ZCL_CLOSE_TUNNEL_COMMAND_ID 0x01 // Ver.: always +#define ZCL_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x02 // Ver.: always #define ZCL_TRANSFER_DATA_ERROR_CLIENT_TO_SERVER_COMMAND_ID 0x03 // Ver.: always -#define ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x04 // Ver.: always -#define ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x05 // Ver.: always -#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 - +#define ZCL_ACK_TRANSFER_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x04 // Ver.: always +#define ZCL_READY_DATA_CLIENT_TO_SERVER_COMMAND_ID 0x05 // Ver.: always +#define ZCL_GET_SUPPORTED_TUNNEL_PROTOCOLS_COMMAND_ID 0x06 // Ver.: since se-1.1a-07-5356-17 // Command types for cluster: Prepayment // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID 0x01 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_PREPAY_SNAPSHOT_COMMAND_ID 0x01 // Ver.: since se-1.2a-07-5356-19 #define ZCL_CHANGE_PAYMENT_MODE_RESPONSE_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_PUBLISH_DEBT_LOG_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMER_TOP_UP_RESPONSE_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_TOP_UP_LOG_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_PUBLISH_DEBT_LOG_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 // Client to server #define ZCL_SELECT_AVAILABLE_EMERGENCY_CREDIT_COMMAND_ID 0x00 // Ver.: always -#define ZCL_CHANGE_DEBT_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CONSUMER_TOP_UP_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CREDIT_ADJUSTMENT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_TOP_UP_LOG_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 -#define ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 -#define ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 - +#define ZCL_CHANGE_DEBT_COMMAND_ID 0x02 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_EMERGENCY_CREDIT_SETUP_COMMAND_ID 0x03 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CONSUMER_TOP_UP_COMMAND_ID 0x04 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CREDIT_ADJUSTMENT_COMMAND_ID 0x05 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_CHANGE_PAYMENT_MODE_COMMAND_ID 0x06 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_PREPAY_SNAPSHOT_COMMAND_ID 0x07 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_TOP_UP_LOG_COMMAND_ID 0x08 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_LOW_CREDIT_WARNING_LEVEL_COMMAND_ID 0x09 // Ver.: since se-1.2a-07-5356-19 +#define ZCL_GET_DEBT_REPAYMENT_LOG_COMMAND_ID 0x0A // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_MAXIMUM_CREDIT_LIMIT_COMMAND_ID 0x0B // Ver.: since se-1.2a-07-5356-19 +#define ZCL_SET_OVERALL_DEBT_CAP_COMMAND_ID 0x0C // Ver.: since se-1.2a-07-5356-19 // Command types for cluster: Energy Management // Cluster specification level: se-1.2b-15-0131-02 @@ -707,61 +673,57 @@ // Client to server #define ZCL_MANAGE_EVENT_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: Calendar // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_PUBLISH_CALENDAR_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PUBLISH_CALENDAR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_DAY_PROFILE_COMMAND_ID 0x01 // Ver.: always #define ZCL_PUBLISH_WEEK_PROFILE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_PUBLISH_SEASONS_COMMAND_ID 0x03 // Ver.: always +#define ZCL_PUBLISH_SEASONS_COMMAND_ID 0x03 // Ver.: always #define ZCL_PUBLISH_SPECIAL_DAYS_COMMAND_ID 0x04 // Ver.: always -#define ZCL_CANCEL_CALENDAR_COMMAND_ID 0x05 // Ver.: always +#define ZCL_CANCEL_CALENDAR_COMMAND_ID 0x05 // Ver.: always // Client to server -#define ZCL_GET_CALENDAR_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GET_DAY_PROFILES_COMMAND_ID 0x01 // Ver.: always -#define ZCL_GET_WEEK_PROFILES_COMMAND_ID 0x02 // Ver.: always -#define ZCL_GET_SEASONS_COMMAND_ID 0x03 // Ver.: always -#define ZCL_GET_SPECIAL_DAYS_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_CALENDAR_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_DAY_PROFILES_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GET_WEEK_PROFILES_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_SEASONS_COMMAND_ID 0x03 // Ver.: always +#define ZCL_GET_SPECIAL_DAYS_COMMAND_ID 0x04 // Ver.: always #define ZCL_GET_CALENDAR_CANCELLATION_COMMAND_ID 0x05 // Ver.: always - // Command types for cluster: Device Management // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PUBLISH_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always #define ZCL_REQUEST_NEW_PASSWORD_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_UPDATE_SITE_ID_COMMAND_ID 0x03 // Ver.: always -#define ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID 0x05 // Ver.: always -#define ZCL_UPDATE_C_I_N_COMMAND_ID 0x06 // Ver.: always +#define ZCL_UPDATE_SITE_ID_COMMAND_ID 0x03 // Ver.: always +#define ZCL_SET_EVENT_CONFIGURATION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_GET_EVENT_CONFIGURATION_COMMAND_ID 0x05 // Ver.: always +#define ZCL_UPDATE_C_I_N_COMMAND_ID 0x06 // Ver.: always // Client to server -#define ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always -#define ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID 0x02 // Ver.: always -#define ZCL_GET_SITE_ID_COMMAND_ID 0x03 // Ver.: always +#define ZCL_GET_CHANGE_OF_TENANCY_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_CHANGE_OF_SUPPLIER_COMMAND_ID 0x01 // Ver.: always +#define ZCL_REQUEST_NEW_PASSWORD_COMMAND_ID 0x02 // Ver.: always +#define ZCL_GET_SITE_ID_COMMAND_ID 0x03 // Ver.: always #define ZCL_REPORT_EVENT_CONFIGURATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_GET_C_I_N_COMMAND_ID 0x05 // Ver.: always - +#define ZCL_GET_C_I_N_COMMAND_ID 0x05 // Ver.: always // Command types for cluster: Events // Cluster specification level: se-1.2b-15-0131-02 // Server to client -#define ZCL_PUBLISH_EVENT_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUBLISH_EVENT_LOG_COMMAND_ID 0x01 // Ver.: always +#define ZCL_PUBLISH_EVENT_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUBLISH_EVENT_LOG_COMMAND_ID 0x01 // Ver.: always #define ZCL_CLEAR_EVENT_LOG_RESPONSE_COMMAND_ID 0x02 // Ver.: always // Client to server -#define ZCL_GET_EVENT_LOG_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_EVENT_LOG_COMMAND_ID 0x00 // Ver.: always #define ZCL_CLEAR_EVENT_LOG_REQUEST_COMMAND_ID 0x01 // Ver.: always - // Command types for cluster: MDU Pairing // Cluster specification level: se-1.2b-15-0131-02 @@ -771,7 +733,6 @@ // Client to server #define ZCL_PAIRING_REQUEST_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: Sub-GHz // Cluster specification level: se-1.2b-15-0131-02 @@ -781,84 +742,79 @@ // Client to server #define ZCL_GET_SUSPEND_ZCL_MESSAGES_STATUS_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: Key Establishment // Cluster specification level: zcl-7.0-07-5123-07 // Server to client #define ZCL_INITIATE_KEY_ESTABLISHMENT_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_EPHEMERAL_DATA_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CONFIRM_KEY_DATA_RESPONSE_COMMAND_ID 0x02 // Ver.: always // Client to server #define ZCL_INITIATE_KEY_ESTABLISHMENT_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID 0x01 // Ver.: always -#define ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_EPHEMERAL_DATA_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_CONFIRM_KEY_DATA_REQUEST_COMMAND_ID 0x02 // Ver.: always // Either direction #define ZCL_TERMINATE_KEY_ESTABLISHMENT_COMMAND_ID 0x03 // Ver.: always - // Command types for cluster: Information // Cluster specification level: ta-1.0-07-5307-07 // Server to client -#define ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUSH_INFORMATION_COMMAND_ID 0x01 // Ver.: always -#define ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_REQUEST_INFORMATION_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUSH_INFORMATION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEND_PREFERENCE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_SERVER_REQUEST_PREFERENCE_COMMAND_ID 0x03 // Ver.: always #define ZCL_REQUEST_PREFERENCE_CONFIRMATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_UPDATE_RESPONSE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_DELETE_RESPONSE_COMMAND_ID 0x06 // Ver.: always +#define ZCL_UPDATE_RESPONSE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_DELETE_RESPONSE_COMMAND_ID 0x06 // Ver.: always // Client to server -#define ZCL_REQUEST_INFORMATION_COMMAND_ID 0x00 // Ver.: always -#define ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_SEND_PREFERENCE_COMMAND_ID 0x02 // Ver.: always -#define ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_UPDATE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_DELETE_COMMAND_ID 0x05 // Ver.: always -#define ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID 0x06 // Ver.: always -#define ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID 0x07 // Ver.: always +#define ZCL_REQUEST_INFORMATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PUSH_INFORMATION_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEND_PREFERENCE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_REQUEST_PREFERENCE_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_UPDATE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_DELETE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_CONFIGURE_NODE_DESCRIPTION_COMMAND_ID 0x06 // Ver.: always +#define ZCL_CONFIGURE_DELIVERY_ENABLE_COMMAND_ID 0x07 // Ver.: always #define ZCL_CONFIGURE_PUSH_INFORMATION_TIMER_COMMAND_ID 0x08 // Ver.: always -#define ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID 0x09 // Ver.: always - +#define ZCL_CONFIGURE_SET_ROOT_ID_COMMAND_ID 0x09 // Ver.: always // Command types for cluster: Data Sharing // Cluster specification level: ta-1.0-07-5307-07 // Server to client -#define ZCL_WRITE_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_MODIFY_FILE_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_WRITE_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_MODIFY_FILE_REQUEST_COMMAND_ID 0x01 // Ver.: always #define ZCL_MODIFY_RECORD_REQUEST_COMMAND_ID 0x02 // Ver.: always -#define ZCL_FILE_TRANSMISSION_COMMAND_ID 0x03 // Ver.: always -#define ZCL_RECORD_TRANSMISSION_COMMAND_ID 0x04 // Ver.: always +#define ZCL_FILE_TRANSMISSION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RECORD_TRANSMISSION_COMMAND_ID 0x04 // Ver.: always // Client to server -#define ZCL_READ_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_READ_FILE_REQUEST_COMMAND_ID 0x00 // Ver.: always #define ZCL_READ_RECORD_REQUEST_COMMAND_ID 0x01 // Ver.: always #define ZCL_WRITE_FILE_RESPONSE_COMMAND_ID 0x02 // Ver.: always - // Command types for cluster: Gaming // Cluster specification level: ta-1.0-07-5307-07 // Server to client #define ZCL_GAME_ANNOUNCEMENT_COMMAND_ID 0x00 // Ver.: always -#define ZCL_GENERAL_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_GENERAL_RESPONSE_COMMAND_ID 0x01 // Ver.: always // Client to server -#define ZCL_SEARCH_GAME_COMMAND_ID 0x00 // Ver.: always -#define ZCL_JOIN_GAME_COMMAND_ID 0x01 // Ver.: always -#define ZCL_START_GAME_COMMAND_ID 0x02 // Ver.: always -#define ZCL_PAUSE_GAME_COMMAND_ID 0x03 // Ver.: always -#define ZCL_RESUME_GAME_COMMAND_ID 0x04 // Ver.: always -#define ZCL_QUIT_GAME_COMMAND_ID 0x05 // Ver.: always -#define ZCL_END_GAME_COMMAND_ID 0x06 // Ver.: always -#define ZCL_START_OVER_COMMAND_ID 0x07 // Ver.: always +#define ZCL_SEARCH_GAME_COMMAND_ID 0x00 // Ver.: always +#define ZCL_JOIN_GAME_COMMAND_ID 0x01 // Ver.: always +#define ZCL_START_GAME_COMMAND_ID 0x02 // Ver.: always +#define ZCL_PAUSE_GAME_COMMAND_ID 0x03 // Ver.: always +#define ZCL_RESUME_GAME_COMMAND_ID 0x04 // Ver.: always +#define ZCL_QUIT_GAME_COMMAND_ID 0x05 // Ver.: always +#define ZCL_END_GAME_COMMAND_ID 0x06 // Ver.: always +#define ZCL_START_OVER_COMMAND_ID 0x07 // Ver.: always #define ZCL_ACTION_CONTROL_COMMAND_ID 0x08 // Ver.: always -#define ZCL_DOWNLOAD_GAME_COMMAND_ID 0x09 // Ver.: always - +#define ZCL_DOWNLOAD_GAME_COMMAND_ID 0x09 // Ver.: always // Command types for cluster: Data Rate Control // Cluster specification level: ta-1.0-07-5307-07 @@ -867,79 +823,74 @@ #define ZCL_DATA_RATE_CONTROL_COMMAND_ID 0x00 // Ver.: always // Client to server -#define ZCL_PATH_CREATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_PATH_CREATION_COMMAND_ID 0x00 // Ver.: always #define ZCL_DATA_RATE_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always -#define ZCL_PATH_DELETION_COMMAND_ID 0x02 // Ver.: always - +#define ZCL_PATH_DELETION_COMMAND_ID 0x02 // Ver.: always // Command types for cluster: Voice over ZigBee // Cluster specification level: ta-1.0-07-5307-07 // Server to client -#define ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ESTABLISHMENT_RESPONSE_COMMAND_ID 0x00 // Ver.: always #define ZCL_VOICE_TRANSMISSION_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_CONTROL_COMMAND_ID 0x02 // Ver.: always +#define ZCL_CONTROL_COMMAND_ID 0x02 // Ver.: always // Client to server -#define ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_VOICE_TRANSMISSION_COMMAND_ID 0x01 // Ver.: always +#define ZCL_ESTABLISHMENT_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_VOICE_TRANSMISSION_COMMAND_ID 0x01 // Ver.: always #define ZCL_VOICE_TRANSMISSION_COMPLETION_COMMAND_ID 0x02 // Ver.: always -#define ZCL_CONTROL_RESPONSE_COMMAND_ID 0x03 // Ver.: always - +#define ZCL_CONTROL_RESPONSE_COMMAND_ID 0x03 // Ver.: always // Command types for cluster: Chatting // Cluster specification level: ta-1.0-07-5307-07 // Server to client -#define ZCL_START_CHAT_RESPONSE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_USER_LEFT_COMMAND_ID 0x02 // Ver.: always -#define ZCL_USER_JOINED_COMMAND_ID 0x03 // Ver.: always -#define ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID 0x04 // Ver.: always -#define ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID 0x05 // Ver.: always -#define ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID 0x06 // Ver.: always -#define ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID 0x07 // Ver.: always +#define ZCL_START_CHAT_RESPONSE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_JOIN_CHAT_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_USER_LEFT_COMMAND_ID 0x02 // Ver.: always +#define ZCL_USER_JOINED_COMMAND_ID 0x03 // Ver.: always +#define ZCL_SEARCH_CHAT_RESPONSE_COMMAND_ID 0x04 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_REQUEST_COMMAND_ID 0x05 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_CONFIRM_COMMAND_ID 0x06 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_NOTIFICATION_COMMAND_ID 0x07 // Ver.: always #define ZCL_GET_NODE_INFORMATION_RESPONSE_COMMAND_ID 0x08 // Ver.: always // Client to server -#define ZCL_JOIN_CHAT_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID 0x01 // Ver.: always -#define ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID 0x02 // Ver.: always -#define ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID 0x03 // Ver.: always -#define ZCL_START_CHAT_REQUEST_COMMAND_ID 0x04 // Ver.: always -#define ZCL_CHAT_MESSAGE_COMMAND_ID 0x05 // Ver.: always +#define ZCL_JOIN_CHAT_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LEAVE_CHAT_REQUEST_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEARCH_CHAT_REQUEST_COMMAND_ID 0x02 // Ver.: always +#define ZCL_SWITCH_CHAIRMAN_RESPONSE_COMMAND_ID 0x03 // Ver.: always +#define ZCL_START_CHAT_REQUEST_COMMAND_ID 0x04 // Ver.: always +#define ZCL_CHAT_MESSAGE_COMMAND_ID 0x05 // Ver.: always #define ZCL_GET_NODE_INFORMATION_REQUEST_COMMAND_ID 0x06 // Ver.: always - // Command types for cluster: Payment // Cluster specification level: ta-1.0-07-5307-07 // Server to client -#define ZCL_BUY_CONFIRM_COMMAND_ID 0x00 // Ver.: always +#define ZCL_BUY_CONFIRM_COMMAND_ID 0x00 // Ver.: always #define ZCL_RECEIPT_DELIVERY_COMMAND_ID 0x01 // Ver.: always -#define ZCL_TRANSACTION_END_COMMAND_ID 0x02 // Ver.: always +#define ZCL_TRANSACTION_END_COMMAND_ID 0x02 // Ver.: always // Client to server -#define ZCL_BUY_REQUEST_COMMAND_ID 0x00 // Ver.: always -#define ZCL_ACCEPT_PAYMENT_COMMAND_ID 0x01 // Ver.: always +#define ZCL_BUY_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_ACCEPT_PAYMENT_COMMAND_ID 0x01 // Ver.: always #define ZCL_PAYMENT_CONFIRM_COMMAND_ID 0x02 // Ver.: always - // Command types for cluster: Billing // Cluster specification level: ta-1.0-07-5307-07 // Server to client #define ZCL_CHECK_BILL_STATUS_COMMAND_ID 0x00 // Ver.: always -#define ZCL_SEND_BILL_RECORD_COMMAND_ID 0x01 // Ver.: always +#define ZCL_SEND_BILL_RECORD_COMMAND_ID 0x01 // Ver.: always // Client to server -#define ZCL_SUBSCRIBE_COMMAND_ID 0x00 // Ver.: always -#define ZCL_UNSUBSCRIBE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_START_BILLING_SESSION_COMMAND_ID 0x02 // Ver.: always -#define ZCL_STOP_BILLING_SESSION_COMMAND_ID 0x03 // Ver.: always +#define ZCL_SUBSCRIBE_COMMAND_ID 0x00 // Ver.: always +#define ZCL_UNSUBSCRIBE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_START_BILLING_SESSION_COMMAND_ID 0x02 // Ver.: always +#define ZCL_STOP_BILLING_SESSION_COMMAND_ID 0x03 // Ver.: always #define ZCL_BILL_STATUS_NOTIFICATION_COMMAND_ID 0x04 // Ver.: always -#define ZCL_SESSION_KEEP_ALIVE_COMMAND_ID 0x05 // Ver.: always - +#define ZCL_SESSION_KEEP_ALIVE_COMMAND_ID 0x05 // Ver.: always // Command types for cluster: Appliance Events and Alert // Cluster specification level: UNKNOWN @@ -952,58 +903,54 @@ // Client to server #define ZCL_GET_ALERTS_COMMAND_ID 0x00 // Ver.: always - // Command types for cluster: Appliance Statistics // Cluster specification level: UNKNOWN // Server to client -#define ZCL_LOG_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always -#define ZCL_LOG_RESPONSE_COMMAND_ID 0x01 // Ver.: always -#define ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID 0x02 // Ver.: always +#define ZCL_LOG_NOTIFICATION_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOG_RESPONSE_COMMAND_ID 0x01 // Ver.: always +#define ZCL_LOG_QUEUE_RESPONSE_COMMAND_ID 0x02 // Ver.: always #define ZCL_STATISTICS_AVAILABLE_COMMAND_ID 0x03 // Ver.: always // Client to server -#define ZCL_LOG_REQUEST_COMMAND_ID 0x00 // Ver.: always +#define ZCL_LOG_REQUEST_COMMAND_ID 0x00 // Ver.: always #define ZCL_LOG_QUEUE_REQUEST_COMMAND_ID 0x01 // Ver.: always - // Command types for cluster: Electrical Measurement // Cluster specification level: UNKNOWN // Server to client -#define ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_PROFILE_INFO_RESPONSE_COMMAND_COMMAND_ID 0x00 // Ver.: always #define ZCL_GET_MEASUREMENT_PROFILE_RESPONSE_COMMAND_COMMAND_ID 0x01 // Ver.: always // Client to server -#define ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID 0x00 // Ver.: always +#define ZCL_GET_PROFILE_INFO_COMMAND_COMMAND_ID 0x00 // Ver.: always #define ZCL_GET_MEASUREMENT_PROFILE_COMMAND_COMMAND_ID 0x01 // Ver.: always - // Command types for cluster: ZLL Commissioning // Cluster specification level: zll-1.0-11-0037-10 // Server to client -#define ZCL_SCAN_RESPONSE_COMMAND_ID 0x01 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID 0x03 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_NETWORK_START_RESPONSE_COMMAND_ID 0x11 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID 0x13 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_SCAN_RESPONSE_COMMAND_ID 0x01 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_DEVICE_INFORMATION_RESPONSE_COMMAND_ID 0x03 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_START_RESPONSE_COMMAND_ID 0x11 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_ROUTER_RESPONSE_COMMAND_ID 0x13 // Ver.: since zll-1.0-11-0037-10 #define ZCL_NETWORK_JOIN_END_DEVICE_RESPONSE_COMMAND_ID 0x15 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_ENDPOINT_INFORMATION_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_ENDPOINT_INFORMATION_COMMAND_ID 0x40 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_GROUP_IDENTIFIERS_RESPONSE_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_ENDPOINT_LIST_RESPONSE_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 // Client to server -#define ZCL_SCAN_REQUEST_COMMAND_ID 0x00 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID 0x02 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_IDENTIFY_REQUEST_COMMAND_ID 0x06 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID 0x07 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_NETWORK_START_REQUEST_COMMAND_ID 0x10 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID 0x12 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_SCAN_REQUEST_COMMAND_ID 0x00 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_DEVICE_INFORMATION_REQUEST_COMMAND_ID 0x02 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_IDENTIFY_REQUEST_COMMAND_ID 0x06 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_RESET_TO_FACTORY_NEW_REQUEST_COMMAND_ID 0x07 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_START_REQUEST_COMMAND_ID 0x10 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_NETWORK_JOIN_ROUTER_REQUEST_COMMAND_ID 0x12 // Ver.: since zll-1.0-11-0037-10 #define ZCL_NETWORK_JOIN_END_DEVICE_REQUEST_COMMAND_ID 0x14 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID 0x16 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 -#define ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 - +#define ZCL_NETWORK_UPDATE_REQUEST_COMMAND_ID 0x16 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_GROUP_IDENTIFIERS_REQUEST_COMMAND_ID 0x41 // Ver.: since zll-1.0-11-0037-10 +#define ZCL_GET_ENDPOINT_LIST_REQUEST_COMMAND_ID 0x42 // Ver.: since zll-1.0-11-0037-10 // Command types for cluster: Sample Mfg Specific Cluster // Cluster specification level: UNKNOWN @@ -1011,14 +958,12 @@ // Client to server #define ZCL_COMMAND_ONE_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 - // Command types for cluster: Sample Mfg Specific Cluster 2 // Cluster specification level: UNKNOWN // Client to server #define ZCL_COMMAND_TWO_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1049 - // Command types for cluster: Configuration Cluster // Cluster specification level: UNKNOWN @@ -1026,70 +971,67 @@ #define ZCL_RETURN_TOKEN_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 // Client to server -#define ZCL_SET_TOKEN_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 -#define ZCL_LOCK_TOKENS_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 -#define ZCL_READ_TOKENS_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 +#define ZCL_SET_TOKEN_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_LOCK_TOKENS_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_READ_TOKENS_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 #define ZCL_UNLOCK_TOKENS_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1002 - // Command types for cluster: MFGLIB Cluster // Cluster specification level: UNKNOWN // Client to server -#define ZCL_STREAM_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 -#define ZCL_TONE_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 +#define ZCL_STREAM_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1002 +#define ZCL_TONE_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1002 #define ZCL_RX_MODE_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1002 - // Command types for cluster: SL Works With All Hubs // Cluster specification level: UNKNOWN // Server to client -#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 -#define ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 -#define ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 -#define ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 -#define ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 -#define ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 -#define ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 -#define ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_RESPONSE_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWERING_OFF_NOTIFICATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWERING_ON_NOTIFICATION_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 +#define ZCL_SHORT_ADDRESS_CHANGE_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_ACK_ENABLEMENT_QUERY_RESPONSE_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 +#define ZCL_POWER_DESCRIPTOR_CHANGE_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 +#define ZCL_NEW_DEBUG_REPORT_NOTIFICATION_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 +#define ZCL_DEBUG_REPORT_QUERY_RESPONSE_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 #define ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_RESPONSE_COMMAND_ID 0x08 // Ver.: always mfgCode: 0x1217 -#define ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 -#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID 0x9E // Ver.: always mfgCode: 0x1217 +#define ZCL_SURVEY_BEACONS_RESPONSE_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 +#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_RESPONSE_COMMAND_ID 0x9E // Ver.: always mfgCode: 0x1217 // Client to server -#define ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 -#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 -#define ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 -#define ZCL_REQUEST_TIME_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x08 // Ver.: always mfgCode: 0x1217 -#define ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 -#define ZCL_CLEAR_BINDING_TABLE_COMMAND_ID 0x0A // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0B // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0C // Ver.: always mfgCode: 0x1217 -#define ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID 0x0D // Ver.: always mfgCode: 0x1217 -#define ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID 0x0E // Ver.: always mfgCode: 0x1217 -#define ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID 0x0F // Ver.: always mfgCode: 0x1217 -#define ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID 0x10 // Ver.: always mfgCode: 0x1217 -#define ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID 0x11 // Ver.: always mfgCode: 0x1217 -#define ZCL_DEBUG_REPORT_QUERY_COMMAND_ID 0x12 // Ver.: always mfgCode: 0x1217 -#define ZCL_SURVEY_BEACONS_COMMAND_ID 0x13 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID 0x14 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID 0x15 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x00 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_APS_LINK_KEY_AUTHORIZATION_COMMAND_ID 0x01 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_LINK_KEY_AUTHORIZATION_QUERY_COMMAND_ID 0x02 // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUEST_NEW_APS_LINK_KEY_COMMAND_ID 0x03 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x04 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_APP_EVENT_RETRY_ALGORITHM_COMMAND_ID 0x05 // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUEST_TIME_COMMAND_ID 0x06 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x07 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_REJOIN_ALGORITHM_COMMAND_ID 0x08 // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_IAS_ZONE_ENROLLMENT_METHOD_COMMAND_ID 0x09 // Ver.: always mfgCode: 0x1217 +#define ZCL_CLEAR_BINDING_TABLE_COMMAND_ID 0x0A // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0B // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_PERIODIC_ROUTER_CHECK_INS_COMMAND_ID 0x0C // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_MAC_POLL_FAILURE_WAIT_TIME_COMMAND_ID 0x0D // Ver.: always mfgCode: 0x1217 +#define ZCL_SET_PENDING_NETWORK_UPDATE_COMMAND_ID 0x0E // Ver.: always mfgCode: 0x1217 +#define ZCL_REQUIRE_APS_ACKS_ON_UNICASTS_COMMAND_ID 0x0F // Ver.: always mfgCode: 0x1217 +#define ZCL_REMOVE_APS_ACKS_ON_UNICASTS_REQUIREMENT_COMMAND_ID 0x10 // Ver.: always mfgCode: 0x1217 +#define ZCL_APS_ACK_REQUIREMENT_QUERY_COMMAND_ID 0x11 // Ver.: always mfgCode: 0x1217 +#define ZCL_DEBUG_REPORT_QUERY_COMMAND_ID 0x12 // Ver.: always mfgCode: 0x1217 +#define ZCL_SURVEY_BEACONS_COMMAND_ID 0x13 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_OTA_DOWNGRADES_COMMAND_ID 0x14 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_MGMT_LEAVE_WITHOUT_REJOIN_COMMAND_ID 0x15 // Ver.: always mfgCode: 0x1217 #define ZCL_DISABLE_TOUCHLINK_INTERPAN_MESSAGE_SUPPORT_COMMAND_ID 0x16 // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x17 // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x18 // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID 0x19 // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1A // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1B // Ver.: always mfgCode: 0x1217 -#define ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID 0x1C // Ver.: always mfgCode: 0x1217 -#define ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID 0x1D // Ver.: always mfgCode: 0x1217 -#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID 0x1E // Ver.: always mfgCode: 0x1217 -#define ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID 0x1F // Ver.: always mfgCode: 0x1217 - +#define ZCL_ENABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x17 // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_PARENT_CLASSIFICATION_COMMAND_ID 0x18 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_TC_SECURITY_ON_NTWK_KEY_ROTATION_COMMAND_ID 0x19 // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1A // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_WWAH_BAD_PARENT_RECOVERY_COMMAND_ID 0x1B // Ver.: always mfgCode: 0x1217 +#define ZCL_ENABLE_CONFIGURATION_MODE_COMMAND_ID 0x1C // Ver.: always mfgCode: 0x1217 +#define ZCL_DISABLE_CONFIGURATION_MODE_COMMAND_ID 0x1D // Ver.: always mfgCode: 0x1217 +#define ZCL_USE_TRUST_CENTER_FOR_CLUSTER_SERVER_COMMAND_ID 0x1E // Ver.: always mfgCode: 0x1217 +#define ZCL_TRUST_CENTER_FOR_CLUSTER_SERVER_QUERY_COMMAND_ID 0x1F // Ver.: always mfgCode: 0x1217 #endif // SILABS_EMBER_AF_COMMAND_ID diff --git a/examples/wifi-echo/server/esp32/main/gen/debug-printing.h b/examples/wifi-echo/server/esp32/main/gen/debug-printing.h index 4cf70a6a7b1760..4eab0f0afc9fcc 100644 --- a/examples/wifi-echo/server/esp32/main/gen/debug-printing.h +++ b/examples/wifi-echo/server/esp32/main/gen/debug-printing.h @@ -39,15 +39,19 @@ #ifndef SILABS_EMBER_AF_DEBUG_PRINTING #define SILABS_EMBER_AF_DEBUG_PRINTING - // Printing macros for cluster: Basic #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER) #define emberAfBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__) -#define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__) +#define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBasicClusterFlush() -#define emberAfBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER) ) { x; } -#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBasicClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace)) #define emberAfBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer)) #else #define emberAfBasicClusterPrint(...) @@ -56,17 +60,21 @@ #define emberAfBasicClusterDebugExec(x) #define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) #define emberAfBasicClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER) // Printing macros for cluster: Power Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) #define emberAfPowerConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__) -#define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPowerConfigClusterFlush() -#define emberAfPowerConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) ) { x; } -#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPowerConfigClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPowerConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer)) #else #define emberAfPowerConfigClusterPrint(...) @@ -75,17 +83,21 @@ #define emberAfPowerConfigClusterDebugExec(x) #define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) #define emberAfPowerConfigClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) // Printing macros for cluster: Device Temperature Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) #define emberAfDeviceTempClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__) -#define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__) +#define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDeviceTempClusterFlush() -#define emberAfDeviceTempClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) ) { x; } -#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDeviceTempClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDeviceTempClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer)) #else #define emberAfDeviceTempClusterPrint(...) @@ -94,17 +106,21 @@ #define emberAfDeviceTempClusterDebugExec(x) #define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) #define emberAfDeviceTempClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) // Printing macros for cluster: Identify #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER) #define emberAfIdentifyClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__) -#define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__) +#define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIdentifyClusterFlush() -#define emberAfIdentifyClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER) ) { x; } -#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIdentifyClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIdentifyClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer)) #else #define emberAfIdentifyClusterPrint(...) @@ -113,17 +129,21 @@ #define emberAfIdentifyClusterDebugExec(x) #define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) #define emberAfIdentifyClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER) // Printing macros for cluster: Groups #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER) #define emberAfGroupsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__) -#define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__) +#define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfGroupsClusterFlush() -#define emberAfGroupsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER) ) { x; } -#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGroupsClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER)) \ + { \ + x; \ + } +#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace)) #define emberAfGroupsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer)) #else #define emberAfGroupsClusterPrint(...) @@ -132,17 +152,21 @@ #define emberAfGroupsClusterDebugExec(x) #define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) #define emberAfGroupsClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER) // Printing macros for cluster: Scenes #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER) #define emberAfScenesClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__) -#define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__) +#define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfScenesClusterFlush() -#define emberAfScenesClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER) ) { x; } -#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfScenesClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER)) \ + { \ + x; \ + } +#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace)) #define emberAfScenesClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer)) #else #define emberAfScenesClusterPrint(...) @@ -151,17 +175,21 @@ #define emberAfScenesClusterDebugExec(x) #define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) #define emberAfScenesClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER) // Printing macros for cluster: On/off #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER) #define emberAfOnOffClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__) -#define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__) +#define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOnOffClusterFlush() -#define emberAfOnOffClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER) ) { x; } -#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOnOffClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace)) #define emberAfOnOffClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer)) #else #define emberAfOnOffClusterPrint(...) @@ -170,17 +198,21 @@ #define emberAfOnOffClusterDebugExec(x) #define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) #define emberAfOnOffClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER) // Printing macros for cluster: On/off Switch Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) #define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__) -#define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOnOffSwitchConfigClusterFlush() -#define emberAfOnOffSwitchConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) ) { x; } -#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOnOffSwitchConfigClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace)) #define emberAfOnOffSwitchConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer)) #else #define emberAfOnOffSwitchConfigClusterPrint(...) @@ -189,17 +221,21 @@ #define emberAfOnOffSwitchConfigClusterDebugExec(x) #define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) #define emberAfOnOffSwitchConfigClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) // Printing macros for cluster: Level Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) #define emberAfLevelControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfLevelControlClusterFlush() -#define emberAfLevelControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) ) { x; } -#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfLevelControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfLevelControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer)) #else #define emberAfLevelControlClusterPrint(...) @@ -208,17 +244,21 @@ #define emberAfLevelControlClusterDebugExec(x) #define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfLevelControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) // Printing macros for cluster: Alarms #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER) #define emberAfAlarmClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__) -#define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__) +#define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfAlarmClusterFlush() -#define emberAfAlarmClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER) ) { x; } -#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfAlarmClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER)) \ + { \ + x; \ + } +#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace)) #define emberAfAlarmClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer)) #else #define emberAfAlarmClusterPrint(...) @@ -227,17 +267,21 @@ #define emberAfAlarmClusterDebugExec(x) #define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) #define emberAfAlarmClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER) // Printing macros for cluster: Time #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER) #define emberAfTimeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__) -#define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__) +#define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTimeClusterFlush() -#define emberAfTimeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER) ) { x; } -#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTimeClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace)) #define emberAfTimeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TIME_CLUSTER, (buffer)) #else #define emberAfTimeClusterPrint(...) @@ -246,17 +290,21 @@ #define emberAfTimeClusterDebugExec(x) #define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) #define emberAfTimeClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER) // Printing macros for cluster: RSSI Location #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) #define emberAfRssiLocationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__) -#define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__) +#define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfRssiLocationClusterFlush() -#define emberAfRssiLocationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) ) { x; } -#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfRssiLocationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace)) #define emberAfRssiLocationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer)) #else #define emberAfRssiLocationClusterPrint(...) @@ -265,17 +313,21 @@ #define emberAfRssiLocationClusterDebugExec(x) #define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) #define emberAfRssiLocationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) // Printing macros for cluster: Binary Input (Basic) #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) #define emberAfBinaryInputBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__) -#define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__) +#define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBinaryInputBasicClusterFlush() -#define emberAfBinaryInputBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) ) { x; } -#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBinaryInputBasicClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace)) #define emberAfBinaryInputBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer)) #else #define emberAfBinaryInputBasicClusterPrint(...) @@ -284,17 +336,21 @@ #define emberAfBinaryInputBasicClusterDebugExec(x) #define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) #define emberAfBinaryInputBasicClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) // Printing macros for cluster: Commissioning #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) #define emberAfCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__) -#define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__) +#define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCommissioningClusterFlush() -#define emberAfCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) ) { x; } -#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCommissioningClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer)) #else #define emberAfCommissioningClusterPrint(...) @@ -303,17 +359,21 @@ #define emberAfCommissioningClusterDebugExec(x) #define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) #define emberAfCommissioningClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) // Printing macros for cluster: Partition #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER) #define emberAfPartitionClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__) -#define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__) +#define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPartitionClusterFlush() -#define emberAfPartitionClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER) ) { x; } -#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPartitionClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPartitionClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer)) #else #define emberAfPartitionClusterPrint(...) @@ -322,17 +382,21 @@ #define emberAfPartitionClusterDebugExec(x) #define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) #define emberAfPartitionClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER) // Printing macros for cluster: Over the Air Bootloading #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) #define emberAfOtaBootloadClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__) -#define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__) +#define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOtaBootloadClusterFlush() -#define emberAfOtaBootloadClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) ) { x; } -#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOtaBootloadClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace)) #define emberAfOtaBootloadClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer)) #else #define emberAfOtaBootloadClusterPrint(...) @@ -341,17 +405,21 @@ #define emberAfOtaBootloadClusterDebugExec(x) #define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) #define emberAfOtaBootloadClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) // Printing macros for cluster: Power Profile #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) #define emberAfPowerProfileClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__) -#define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__) +#define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPowerProfileClusterFlush() -#define emberAfPowerProfileClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) ) { x; } -#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPowerProfileClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPowerProfileClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer)) #else #define emberAfPowerProfileClusterPrint(...) @@ -360,17 +428,21 @@ #define emberAfPowerProfileClusterDebugExec(x) #define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) #define emberAfPowerProfileClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) // Printing macros for cluster: Appliance Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) #define emberAfApplianceControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfApplianceControlClusterFlush() -#define emberAfApplianceControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) ) { x; } -#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfApplianceControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer)) #else #define emberAfApplianceControlClusterPrint(...) @@ -379,17 +451,21 @@ #define emberAfApplianceControlClusterDebugExec(x) #define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfApplianceControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) // Printing macros for cluster: Poll Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) #define emberAfPollControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPollControlClusterFlush() -#define emberAfPollControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) ) { x; } -#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPollControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPollControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer)) #else #define emberAfPollControlClusterPrint(...) @@ -398,17 +474,21 @@ #define emberAfPollControlClusterDebugExec(x) #define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfPollControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) // Printing macros for cluster: Green Power #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) #define emberAfGreenPowerClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__) -#define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__) +#define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfGreenPowerClusterFlush() -#define emberAfGreenPowerClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) ) { x; } -#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGreenPowerClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)) \ + { \ + x; \ + } +#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace)) #define emberAfGreenPowerClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer)) #else #define emberAfGreenPowerClusterPrint(...) @@ -417,17 +497,21 @@ #define emberAfGreenPowerClusterDebugExec(x) #define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) #define emberAfGreenPowerClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) // Printing macros for cluster: Keep-Alive #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) #define emberAfKeepaliveClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__) -#define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__) +#define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfKeepaliveClusterFlush() -#define emberAfKeepaliveClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) ) { x; } -#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfKeepaliveClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfKeepaliveClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer)) #else #define emberAfKeepaliveClusterPrint(...) @@ -436,17 +520,21 @@ #define emberAfKeepaliveClusterDebugExec(x) #define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) #define emberAfKeepaliveClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) // Printing macros for cluster: Shade Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) #define emberAfShadeConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__) -#define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfShadeConfigClusterFlush() -#define emberAfShadeConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) ) { x; } -#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfShadeConfigClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)) \ + { \ + x; \ + } +#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace)) #define emberAfShadeConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer)) #else #define emberAfShadeConfigClusterPrint(...) @@ -455,17 +543,21 @@ #define emberAfShadeConfigClusterDebugExec(x) #define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) #define emberAfShadeConfigClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) // Printing macros for cluster: Door Lock #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) #define emberAfDoorLockClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__) -#define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__) +#define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDoorLockClusterFlush() -#define emberAfDoorLockClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) ) { x; } -#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDoorLockClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDoorLockClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer)) #else #define emberAfDoorLockClusterPrint(...) @@ -474,17 +566,21 @@ #define emberAfDoorLockClusterDebugExec(x) #define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) #define emberAfDoorLockClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) // Printing macros for cluster: Window Covering #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) #define emberAfWindowCoveringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__) -#define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__) +#define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfWindowCoveringClusterFlush() -#define emberAfWindowCoveringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) ) { x; } -#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfWindowCoveringClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfWindowCoveringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer)) #else #define emberAfWindowCoveringClusterPrint(...) @@ -493,17 +589,21 @@ #define emberAfWindowCoveringClusterDebugExec(x) #define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) #define emberAfWindowCoveringClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) // Printing macros for cluster: Barrier Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) #define emberAfBarrierControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBarrierControlClusterFlush() -#define emberAfBarrierControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) ) { x; } -#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBarrierControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfBarrierControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer)) #else #define emberAfBarrierControlClusterPrint(...) @@ -512,17 +612,21 @@ #define emberAfBarrierControlClusterDebugExec(x) #define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfBarrierControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) // Printing macros for cluster: Pump Configuration and Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) #define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPumpConfigControlClusterFlush() -#define emberAfPumpConfigControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) ) { x; } -#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPumpConfigControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPumpConfigControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer)) #else #define emberAfPumpConfigControlClusterPrint(...) @@ -531,17 +635,21 @@ #define emberAfPumpConfigControlClusterDebugExec(x) #define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfPumpConfigControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) // Printing macros for cluster: Thermostat #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) #define emberAfThermostatClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__) -#define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__) +#define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfThermostatClusterFlush() -#define emberAfThermostatClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) ) { x; } -#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfThermostatClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfThermostatClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer)) #else #define emberAfThermostatClusterPrint(...) @@ -550,17 +658,21 @@ #define emberAfThermostatClusterDebugExec(x) #define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) #define emberAfThermostatClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) // Printing macros for cluster: Fan Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) #define emberAfFanControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfFanControlClusterFlush() -#define emberAfFanControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) ) { x; } -#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFanControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfFanControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer)) #else #define emberAfFanControlClusterPrint(...) @@ -569,17 +681,21 @@ #define emberAfFanControlClusterDebugExec(x) #define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfFanControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) // Printing macros for cluster: Dehumidification Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) #define emberAfDehumidControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDehumidControlClusterFlush() -#define emberAfDehumidControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) ) { x; } -#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDehumidControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDehumidControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer)) #else #define emberAfDehumidControlClusterPrint(...) @@ -588,18 +704,23 @@ #define emberAfDehumidControlClusterDebugExec(x) #define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfDehumidControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) // Printing macros for cluster: Thermostat User Interface Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) #define emberAfThermostatUiConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__) -#define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__) +#define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfThermostatUiConfigClusterFlush() -#define emberAfThermostatUiConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) ) { x; } -#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfThermostatUiConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer)) +#define emberAfThermostatUiConfigClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)) \ + { \ + x; \ + } +#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfThermostatUiConfigClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer)) #else #define emberAfThermostatUiConfigClusterPrint(...) #define emberAfThermostatUiConfigClusterPrintln(...) @@ -607,17 +728,21 @@ #define emberAfThermostatUiConfigClusterDebugExec(x) #define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) #define emberAfThermostatUiConfigClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) // Printing macros for cluster: Color Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) #define emberAfColorControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfColorControlClusterFlush() -#define emberAfColorControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) ) { x; } -#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfColorControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfColorControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer)) #else #define emberAfColorControlClusterPrint(...) @@ -626,18 +751,23 @@ #define emberAfColorControlClusterDebugExec(x) #define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfColorControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) // Printing macros for cluster: Ballast Configuration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) #define emberAfBallastConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__) -#define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__) +#define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBallastConfigurationClusterFlush() -#define emberAfBallastConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) ) { x; } -#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfBallastConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer)) +#define emberAfBallastConfigurationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBallastConfigurationClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer)) #else #define emberAfBallastConfigurationClusterPrint(...) #define emberAfBallastConfigurationClusterPrintln(...) @@ -645,17 +775,21 @@ #define emberAfBallastConfigurationClusterDebugExec(x) #define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) #define emberAfBallastConfigurationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) // Printing macros for cluster: Illuminance Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) #define emberAfIllumMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIllumMeasurementClusterFlush() -#define emberAfIllumMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIllumMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIllumMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfIllumMeasurementClusterPrint(...) @@ -664,17 +798,21 @@ #define emberAfIllumMeasurementClusterDebugExec(x) #define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfIllumMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) // Printing macros for cluster: Illuminance Level Sensing #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) #define emberAfIllumLevelSensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__) -#define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__) +#define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIllumLevelSensingClusterFlush() -#define emberAfIllumLevelSensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) ) { x; } -#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIllumLevelSensingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIllumLevelSensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer)) #else #define emberAfIllumLevelSensingClusterPrint(...) @@ -683,17 +821,21 @@ #define emberAfIllumLevelSensingClusterDebugExec(x) #define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) #define emberAfIllumLevelSensingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) // Printing macros for cluster: Temperature Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) #define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTempMeasurementClusterFlush() -#define emberAfTempMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTempMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfTempMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfTempMeasurementClusterPrint(...) @@ -702,18 +844,23 @@ #define emberAfTempMeasurementClusterDebugExec(x) #define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfTempMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) // Printing macros for cluster: Pressure Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) #define emberAfPressureMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPressureMeasurementClusterFlush() -#define emberAfPressureMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfPressureMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfPressureMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPressureMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfPressureMeasurementClusterPrint(...) #define emberAfPressureMeasurementClusterPrintln(...) @@ -721,17 +868,21 @@ #define emberAfPressureMeasurementClusterDebugExec(x) #define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfPressureMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) // Printing macros for cluster: Flow Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) #define emberAfFlowMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfFlowMeasurementClusterFlush() -#define emberAfFlowMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFlowMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfFlowMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfFlowMeasurementClusterPrint(...) @@ -740,18 +891,25 @@ #define emberAfFlowMeasurementClusterDebugExec(x) #define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfFlowMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) // Printing macros for cluster: Relative Humidity Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) -#define emberAfRelativeHumidityMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfRelativeHumidityMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfRelativeHumidityMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfRelativeHumidityMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfRelativeHumidityMeasurementClusterFlush() -#define emberAfRelativeHumidityMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfRelativeHumidityMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfRelativeHumidityMeasurementClusterPrint(...) #define emberAfRelativeHumidityMeasurementClusterPrintln(...) @@ -759,17 +917,21 @@ #define emberAfRelativeHumidityMeasurementClusterDebugExec(x) #define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) // Printing macros for cluster: Occupancy Sensing #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) #define emberAfOccupancySensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__) -#define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__) +#define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOccupancySensingClusterFlush() -#define emberAfOccupancySensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) ) { x; } -#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOccupancySensingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfOccupancySensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer)) #else #define emberAfOccupancySensingClusterPrint(...) @@ -778,18 +940,25 @@ #define emberAfOccupancySensingClusterDebugExec(x) #define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) #define emberAfOccupancySensingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) // Printing macros for cluster: Carbon Monoxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush() -#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) @@ -797,18 +966,25 @@ #define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Carbon Dioxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCarbonDioxideConcentrationMeasurementClusterFlush() -#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) @@ -816,18 +992,25 @@ #define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Ethylene Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfEthyleneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfEthyleneConcentrationMeasurementClusterFlush() -#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfEthyleneConcentrationMeasurementClusterPrint(...) #define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) @@ -835,18 +1018,25 @@ #define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) #define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Ethylene Oxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfEthyleneOxideConcentrationMeasurementClusterFlush() -#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) @@ -854,18 +1044,25 @@ #define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Hydrogen Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfHydrogenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfHydrogenConcentrationMeasurementClusterFlush() -#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfHydrogenConcentrationMeasurementClusterPrint(...) #define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) @@ -873,18 +1070,25 @@ #define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) #define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Hydrogen Sulphide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush() -#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) @@ -892,18 +1096,25 @@ #define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Nitric Oxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfNitricOxideConcentrationMeasurementClusterFlush() -#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) #define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) @@ -911,18 +1122,25 @@ #define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) #define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Nitrogen Dioxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush() -#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) @@ -930,18 +1148,25 @@ #define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Oxygen Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOxygenConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOxygenConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOxygenConcentrationMeasurementClusterFlush() -#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfOxygenConcentrationMeasurementClusterPrint(...) #define emberAfOxygenConcentrationMeasurementClusterPrintln(...) @@ -949,18 +1174,25 @@ #define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) #define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Ozone Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfOzoneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfOzoneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOzoneConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfOzoneConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOzoneConcentrationMeasurementClusterFlush() -#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfOzoneConcentrationMeasurementClusterPrint(...) #define emberAfOzoneConcentrationMeasurementClusterPrintln(...) @@ -968,18 +1200,25 @@ #define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) #define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Sulfur Dioxide Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSulfurDioxideConcentrationMeasurementClusterFlush() -#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) @@ -987,18 +1226,25 @@ #define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Dissolved Oxygen Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush() -#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) @@ -1006,18 +1252,25 @@ #define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Bromate Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfBromateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfBromateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromateConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromateConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBromateConcentrationMeasurementClusterFlush() -#define emberAfBromateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfBromateConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfBromateConcentrationMeasurementClusterPrint(...) #define emberAfBromateConcentrationMeasurementClusterPrintln(...) @@ -1025,18 +1278,25 @@ #define emberAfBromateConcentrationMeasurementClusterDebugExec(x) #define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Chloramines Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfChloraminesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloraminesConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfChloraminesConcentrationMeasurementClusterFlush() -#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfChloraminesConcentrationMeasurementClusterPrint(...) #define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) @@ -1044,18 +1304,25 @@ #define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) #define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Chlorine Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfChlorineConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfChlorineConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorineConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorineConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfChlorineConcentrationMeasurementClusterFlush() -#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfChlorineConcentrationMeasurementClusterPrint(...) #define emberAfChlorineConcentrationMeasurementClusterPrintln(...) @@ -1063,18 +1330,25 @@ #define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) #define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Fecal coliform and E. Coli Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush() -#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) @@ -1082,18 +1356,25 @@ #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Fluoride Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfFluorideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfFluorideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFluorideConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfFluorideConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfFluorideConcentrationMeasurementClusterFlush() -#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfFluorideConcentrationMeasurementClusterPrint(...) #define emberAfFluorideConcentrationMeasurementClusterPrintln(...) @@ -1101,18 +1382,25 @@ #define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) #define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Haloacetic Acids Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush() -#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) @@ -1120,18 +1408,25 @@ #define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Total Trihalomethanes Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush() -#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) @@ -1139,18 +1434,25 @@ #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Total Coliform Bacteria Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush() -#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) @@ -1158,18 +1460,25 @@ #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Turbidity Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfTurbidityConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTurbidityConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTurbidityConcentrationMeasurementClusterFlush() -#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfTurbidityConcentrationMeasurementClusterPrint(...) #define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) @@ -1177,18 +1486,25 @@ #define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) #define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Copper Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfCopperConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfCopperConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCopperConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfCopperConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCopperConcentrationMeasurementClusterFlush() -#define emberAfCopperConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfCopperConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfCopperConcentrationMeasurementClusterPrint(...) #define emberAfCopperConcentrationMeasurementClusterPrintln(...) @@ -1196,18 +1512,25 @@ #define emberAfCopperConcentrationMeasurementClusterDebugExec(x) #define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Lead Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfLeadConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfLeadConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfLeadConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfLeadConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfLeadConcentrationMeasurementClusterFlush() -#define emberAfLeadConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfLeadConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfLeadConcentrationMeasurementClusterPrint(...) #define emberAfLeadConcentrationMeasurementClusterPrintln(...) @@ -1215,18 +1538,25 @@ #define emberAfLeadConcentrationMeasurementClusterDebugExec(x) #define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Manganese Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfManganeseConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfManganeseConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfManganeseConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfManganeseConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfManganeseConcentrationMeasurementClusterFlush() -#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfManganeseConcentrationMeasurementClusterPrint(...) #define emberAfManganeseConcentrationMeasurementClusterPrintln(...) @@ -1234,18 +1564,25 @@ #define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) #define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Sulfate Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfSulfateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfSulfateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfateConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSulfateConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSulfateConcentrationMeasurementClusterFlush() -#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfSulfateConcentrationMeasurementClusterPrint(...) #define emberAfSulfateConcentrationMeasurementClusterPrintln(...) @@ -1253,18 +1590,25 @@ #define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) #define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Bromodichloromethane Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush() -#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) @@ -1272,18 +1616,25 @@ #define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Bromoform Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfBromoformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfBromoformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromoformConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfBromoformConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBromoformConcentrationMeasurementClusterFlush() -#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfBromoformConcentrationMeasurementClusterPrint(...) #define emberAfBromoformConcentrationMeasurementClusterPrintln(...) @@ -1291,18 +1642,25 @@ #define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) #define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Chlorodibromomethane Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush() -#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) @@ -1310,18 +1668,25 @@ #define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Chloroform Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfChloroformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfChloroformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloroformConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfChloroformConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfChloroformConcentrationMeasurementClusterFlush() -#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfChloroformConcentrationMeasurementClusterPrint(...) #define emberAfChloroformConcentrationMeasurementClusterPrintln(...) @@ -1329,18 +1694,25 @@ #define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) #define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: Sodium Concentration Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) -#define emberAfSodiumConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfSodiumConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSodiumConcentrationMeasurementClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfSodiumConcentrationMeasurementClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSodiumConcentrationMeasurementClusterFlush() -#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfSodiumConcentrationMeasurementClusterPrint(...) #define emberAfSodiumConcentrationMeasurementClusterPrintln(...) @@ -1348,17 +1720,21 @@ #define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) #define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) // Printing macros for cluster: IAS Zone #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) #define emberAfIasZoneClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__) -#define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__) +#define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIasZoneClusterFlush() -#define emberAfIasZoneClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) ) { x; } -#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasZoneClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIasZoneClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer)) #else #define emberAfIasZoneClusterPrint(...) @@ -1367,17 +1743,21 @@ #define emberAfIasZoneClusterDebugExec(x) #define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) #define emberAfIasZoneClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) // Printing macros for cluster: IAS ACE #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER) #define emberAfIasAceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__) -#define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__) +#define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIasAceClusterFlush() -#define emberAfIasAceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER) ) { x; } -#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasAceClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIasAceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer)) #else #define emberAfIasAceClusterPrint(...) @@ -1386,17 +1766,21 @@ #define emberAfIasAceClusterDebugExec(x) #define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) #define emberAfIasAceClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER) // Printing macros for cluster: IAS WD #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER) #define emberAfIasWdClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__) -#define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__) +#define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIasWdClusterFlush() -#define emberAfIasWdClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER) ) { x; } -#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIasWdClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace)) #define emberAfIasWdClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer)) #else #define emberAfIasWdClusterPrint(...) @@ -1405,17 +1789,21 @@ #define emberAfIasWdClusterDebugExec(x) #define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) #define emberAfIasWdClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER) // Printing macros for cluster: Generic Tunnel #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) #define emberAfGenericTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__) -#define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfGenericTunnelClusterFlush() -#define emberAfGenericTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) ) { x; } -#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGenericTunnelClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfGenericTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer)) #else #define emberAfGenericTunnelClusterPrint(...) @@ -1424,18 +1812,23 @@ #define emberAfGenericTunnelClusterDebugExec(x) #define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) #define emberAfGenericTunnelClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) // Printing macros for cluster: BACnet Protocol Tunnel #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) #define emberAfBacnetProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) -#define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBacnetProtocolTunnelClusterFlush() -#define emberAfBacnetProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) ) { x; } -#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfBacnetProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#define emberAfBacnetProtocolTunnelClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBacnetProtocolTunnelClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer)) #else #define emberAfBacnetProtocolTunnelClusterPrint(...) #define emberAfBacnetProtocolTunnelClusterPrintln(...) @@ -1443,18 +1836,23 @@ #define emberAfBacnetProtocolTunnelClusterDebugExec(x) #define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) #define emberAfBacnetProtocolTunnelClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) // Printing macros for cluster: 11073 Protocol Tunnel #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) #define emberAf11073ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) -#define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAf11073ProtocolTunnelClusterFlush() -#define emberAf11073ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) ) { x; } -#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) -#define emberAf11073ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#define emberAf11073ProtocolTunnelClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)) \ + { \ + x; \ + } +#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAf11073ProtocolTunnelClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer)) #else #define emberAf11073ProtocolTunnelClusterPrint(...) #define emberAf11073ProtocolTunnelClusterPrintln(...) @@ -1462,18 +1860,23 @@ #define emberAf11073ProtocolTunnelClusterDebugExec(x) #define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) #define emberAf11073ProtocolTunnelClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) // Printing macros for cluster: ISO 7816 Protocol Tunnel #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) #define emberAfIso7816ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) -#define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) +#define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfIso7816ProtocolTunnelClusterFlush() -#define emberAfIso7816ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) ) { x; } -#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer)) +#define emberAfIso7816ProtocolTunnelClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer)) #else #define emberAfIso7816ProtocolTunnelClusterPrint(...) #define emberAfIso7816ProtocolTunnelClusterPrintln(...) @@ -1481,17 +1884,21 @@ #define emberAfIso7816ProtocolTunnelClusterDebugExec(x) #define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) #define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) // Printing macros for cluster: Price #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER) #define emberAfPriceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__) -#define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__) +#define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPriceClusterFlush() -#define emberAfPriceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER) ) { x; } -#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPriceClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPriceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer)) #else #define emberAfPriceClusterPrint(...) @@ -1500,18 +1907,25 @@ #define emberAfPriceClusterDebugExec(x) #define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) #define emberAfPriceClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER) // Printing macros for cluster: Demand Response and Load Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) -#define emberAfDemandResponseLoadControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfDemandResponseLoadControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDemandResponseLoadControlClusterPrint(...) \ + emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDemandResponseLoadControlClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDemandResponseLoadControlClusterFlush() -#define emberAfDemandResponseLoadControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) ) { x; } -#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfDemandResponseLoadControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer)) +#define emberAfDemandResponseLoadControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDemandResponseLoadControlClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer)) #else #define emberAfDemandResponseLoadControlClusterPrint(...) #define emberAfDemandResponseLoadControlClusterPrintln(...) @@ -1519,17 +1933,21 @@ #define emberAfDemandResponseLoadControlClusterDebugExec(x) #define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfDemandResponseLoadControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) // Printing macros for cluster: Simple Metering #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) #define emberAfSimpleMeteringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__) -#define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__) +#define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSimpleMeteringClusterFlush() -#define emberAfSimpleMeteringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) ) { x; } -#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSimpleMeteringClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfSimpleMeteringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer)) #else #define emberAfSimpleMeteringClusterPrint(...) @@ -1538,17 +1956,21 @@ #define emberAfSimpleMeteringClusterDebugExec(x) #define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) #define emberAfSimpleMeteringClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) // Printing macros for cluster: Messaging #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER) #define emberAfMessagingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__) -#define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__) +#define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfMessagingClusterFlush() -#define emberAfMessagingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER) ) { x; } -#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMessagingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfMessagingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer)) #else #define emberAfMessagingClusterPrint(...) @@ -1557,17 +1979,21 @@ #define emberAfMessagingClusterDebugExec(x) #define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) #define emberAfMessagingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER) // Printing macros for cluster: Tunneling #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER) #define emberAfTunnelingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__) -#define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__) +#define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfTunnelingClusterFlush() -#define emberAfTunnelingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER) ) { x; } -#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfTunnelingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfTunnelingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer)) #else #define emberAfTunnelingClusterPrint(...) @@ -1576,17 +2002,21 @@ #define emberAfTunnelingClusterDebugExec(x) #define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) #define emberAfTunnelingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER) // Printing macros for cluster: Prepayment #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) #define emberAfPrepaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__) -#define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__) +#define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPrepaymentClusterFlush() -#define emberAfPrepaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) ) { x; } -#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPrepaymentClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPrepaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer)) #else #define emberAfPrepaymentClusterPrint(...) @@ -1595,17 +2025,21 @@ #define emberAfPrepaymentClusterDebugExec(x) #define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) #define emberAfPrepaymentClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) // Printing macros for cluster: Energy Management #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) #define emberAfEnergyManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__) -#define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__) +#define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfEnergyManagementClusterFlush() -#define emberAfEnergyManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) ) { x; } -#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEnergyManagementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfEnergyManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer)) #else #define emberAfEnergyManagementClusterPrint(...) @@ -1614,17 +2048,21 @@ #define emberAfEnergyManagementClusterDebugExec(x) #define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) #define emberAfEnergyManagementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) // Printing macros for cluster: Calendar #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER) #define emberAfCalendarClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__) -#define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__) +#define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCalendarClusterFlush() -#define emberAfCalendarClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER) ) { x; } -#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfCalendarClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER)) \ + { \ + x; \ + } +#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace)) #define emberAfCalendarClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer)) #else #define emberAfCalendarClusterPrint(...) @@ -1633,17 +2071,21 @@ #define emberAfCalendarClusterDebugExec(x) #define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) #define emberAfCalendarClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER) // Printing macros for cluster: Device Management #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) #define emberAfDeviceManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__) -#define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__) +#define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDeviceManagementClusterFlush() -#define emberAfDeviceManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) ) { x; } -#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDeviceManagementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDeviceManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer)) #else #define emberAfDeviceManagementClusterPrint(...) @@ -1652,17 +2094,21 @@ #define emberAfDeviceManagementClusterDebugExec(x) #define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) #define emberAfDeviceManagementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) // Printing macros for cluster: Events #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER) #define emberAfEventsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__) -#define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__) +#define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfEventsClusterFlush() -#define emberAfEventsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER) ) { x; } -#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfEventsClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER)) \ + { \ + x; \ + } +#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace)) #define emberAfEventsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer)) #else #define emberAfEventsClusterPrint(...) @@ -1671,17 +2117,21 @@ #define emberAfEventsClusterDebugExec(x) #define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) #define emberAfEventsClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER) // Printing macros for cluster: MDU Pairing #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) #define emberAfMduPairingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__) -#define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__) +#define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfMduPairingClusterFlush() -#define emberAfMduPairingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) ) { x; } -#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMduPairingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfMduPairingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer)) #else #define emberAfMduPairingClusterPrint(...) @@ -1690,17 +2140,21 @@ #define emberAfMduPairingClusterDebugExec(x) #define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) #define emberAfMduPairingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) // Printing macros for cluster: Sub-GHz #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) #define emberAfSubGhzClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__) -#define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__) +#define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSubGhzClusterFlush() -#define emberAfSubGhzClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) ) { x; } -#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSubGhzClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace)) #define emberAfSubGhzClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer)) #else #define emberAfSubGhzClusterPrint(...) @@ -1709,17 +2163,21 @@ #define emberAfSubGhzClusterDebugExec(x) #define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) #define emberAfSubGhzClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) // Printing macros for cluster: Key Establishment #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) #define emberAfKeyEstablishmentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__) -#define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__) +#define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfKeyEstablishmentClusterFlush() -#define emberAfKeyEstablishmentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) ) { x; } -#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfKeyEstablishmentClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfKeyEstablishmentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer)) #else #define emberAfKeyEstablishmentClusterPrint(...) @@ -1728,17 +2186,21 @@ #define emberAfKeyEstablishmentClusterDebugExec(x) #define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) #define emberAfKeyEstablishmentClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) // Printing macros for cluster: Information #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER) #define emberAfInformationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__) -#define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__) +#define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfInformationClusterFlush() -#define emberAfInformationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER) ) { x; } -#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfInformationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace)) #define emberAfInformationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer)) #else #define emberAfInformationClusterPrint(...) @@ -1747,17 +2209,21 @@ #define emberAfInformationClusterDebugExec(x) #define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) #define emberAfInformationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER) // Printing macros for cluster: Data Sharing #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) #define emberAfDataSharingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__) -#define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__) +#define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDataSharingClusterFlush() -#define emberAfDataSharingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) ) { x; } -#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDataSharingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDataSharingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer)) #else #define emberAfDataSharingClusterPrint(...) @@ -1766,17 +2232,21 @@ #define emberAfDataSharingClusterDebugExec(x) #define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) #define emberAfDataSharingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) // Printing macros for cluster: Gaming #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER) #define emberAfGamingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__) -#define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__) +#define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfGamingClusterFlush() -#define emberAfGamingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER) ) { x; } -#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfGamingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfGamingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer)) #else #define emberAfGamingClusterPrint(...) @@ -1785,17 +2255,21 @@ #define emberAfGamingClusterDebugExec(x) #define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) #define emberAfGamingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER) // Printing macros for cluster: Data Rate Control #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) #define emberAfDataRateControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__) -#define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__) +#define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDataRateControlClusterFlush() -#define emberAfDataRateControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) ) { x; } -#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDataRateControlClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDataRateControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer)) #else #define emberAfDataRateControlClusterPrint(...) @@ -1804,17 +2278,21 @@ #define emberAfDataRateControlClusterDebugExec(x) #define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) #define emberAfDataRateControlClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) // Printing macros for cluster: Voice over ZigBee #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) #define emberAfVoiceOverZigbeeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__) -#define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__) +#define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfVoiceOverZigbeeClusterFlush() -#define emberAfVoiceOverZigbeeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) ) { x; } -#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfVoiceOverZigbeeClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)) \ + { \ + x; \ + } +#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace)) #define emberAfVoiceOverZigbeeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer)) #else #define emberAfVoiceOverZigbeeClusterPrint(...) @@ -1823,17 +2301,21 @@ #define emberAfVoiceOverZigbeeClusterDebugExec(x) #define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) #define emberAfVoiceOverZigbeeClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) // Printing macros for cluster: Chatting #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER) #define emberAfChattingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__) -#define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__) +#define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfChattingClusterFlush() -#define emberAfChattingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER) ) { x; } -#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfChattingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfChattingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer)) #else #define emberAfChattingClusterPrint(...) @@ -1842,17 +2324,21 @@ #define emberAfChattingClusterDebugExec(x) #define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) #define emberAfChattingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER) // Printing macros for cluster: Payment #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER) #define emberAfPaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__) -#define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__) +#define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfPaymentClusterFlush() -#define emberAfPaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER) ) { x; } -#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfPaymentClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace)) #define emberAfPaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer)) #else #define emberAfPaymentClusterPrint(...) @@ -1861,17 +2347,21 @@ #define emberAfPaymentClusterDebugExec(x) #define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) #define emberAfPaymentClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER) // Printing macros for cluster: Billing #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER) #define emberAfBillingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__) -#define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__) +#define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfBillingClusterFlush() -#define emberAfBillingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER) ) { x; } -#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfBillingClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfBillingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer)) #else #define emberAfBillingClusterPrint(...) @@ -1880,18 +2370,24 @@ #define emberAfBillingClusterDebugExec(x) #define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) #define emberAfBillingClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER) // Printing macros for cluster: Appliance Identification #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) #define emberAfApplianceIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__) -#define emberAfApplianceIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__) +#define emberAfApplianceIdentificationClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfApplianceIdentificationClusterFlush() -#define emberAfApplianceIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) ) { x; } -#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfApplianceIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer)) +#define emberAfApplianceIdentificationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceIdentificationClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer)) #else #define emberAfApplianceIdentificationClusterPrint(...) #define emberAfApplianceIdentificationClusterPrintln(...) @@ -1899,18 +2395,23 @@ #define emberAfApplianceIdentificationClusterDebugExec(x) #define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) #define emberAfApplianceIdentificationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) // Printing macros for cluster: Meter Identification #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) #define emberAfMeterIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__) -#define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__) +#define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfMeterIdentificationClusterFlush() -#define emberAfMeterIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) ) { x; } -#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfMeterIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer)) +#define emberAfMeterIdentificationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMeterIdentificationClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer)) #else #define emberAfMeterIdentificationClusterPrint(...) #define emberAfMeterIdentificationClusterPrintln(...) @@ -1918,18 +2419,24 @@ #define emberAfMeterIdentificationClusterDebugExec(x) #define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) #define emberAfMeterIdentificationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) // Printing macros for cluster: Appliance Events and Alert #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) #define emberAfApplianceEventsAndAlertClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__) -#define emberAfApplianceEventsAndAlertClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__) +#define emberAfApplianceEventsAndAlertClusterPrintln(...) \ + emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfApplianceEventsAndAlertClusterFlush() -#define emberAfApplianceEventsAndAlertClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) ) { x; } -#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfApplianceEventsAndAlertClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer)) +#define emberAfApplianceEventsAndAlertClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceEventsAndAlertClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer)) #else #define emberAfApplianceEventsAndAlertClusterPrint(...) #define emberAfApplianceEventsAndAlertClusterPrintln(...) @@ -1937,18 +2444,23 @@ #define emberAfApplianceEventsAndAlertClusterDebugExec(x) #define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) #define emberAfApplianceEventsAndAlertClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) // Printing macros for cluster: Appliance Statistics #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) #define emberAfApplianceStatisticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__) -#define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__) +#define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfApplianceStatisticsClusterFlush() -#define emberAfApplianceStatisticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) ) { x; } -#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfApplianceStatisticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer)) +#define emberAfApplianceStatisticsClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)) \ + { \ + x; \ + } +#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfApplianceStatisticsClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer)) #else #define emberAfApplianceStatisticsClusterPrint(...) #define emberAfApplianceStatisticsClusterPrintln(...) @@ -1956,18 +2468,23 @@ #define emberAfApplianceStatisticsClusterDebugExec(x) #define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) #define emberAfApplianceStatisticsClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) // Printing macros for cluster: Electrical Measurement #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) #define emberAfElectricalMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__) -#define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__) +#define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfElectricalMeasurementClusterFlush() -#define emberAfElectricalMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) ) { x; } -#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) -#define emberAfElectricalMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer)) +#define emberAfElectricalMeasurementClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)) \ + { \ + x; \ + } +#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfElectricalMeasurementClusterPrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer)) #else #define emberAfElectricalMeasurementClusterPrint(...) #define emberAfElectricalMeasurementClusterPrintln(...) @@ -1975,17 +2492,21 @@ #define emberAfElectricalMeasurementClusterDebugExec(x) #define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) #define emberAfElectricalMeasurementClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) // Printing macros for cluster: Diagnostics #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) #define emberAfDiagnosticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__) -#define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__) +#define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDiagnosticsClusterFlush() -#define emberAfDiagnosticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) ) { x; } -#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfDiagnosticsClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)) \ + { \ + x; \ + } +#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace)) #define emberAfDiagnosticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer)) #else #define emberAfDiagnosticsClusterPrint(...) @@ -1994,17 +2515,21 @@ #define emberAfDiagnosticsClusterDebugExec(x) #define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) #define emberAfDiagnosticsClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) // Printing macros for cluster: ZLL Commissioning #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) #define emberAfZllCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__) -#define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__) +#define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfZllCommissioningClusterFlush() -#define emberAfZllCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) ) { x; } -#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfZllCommissioningClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)) \ + { \ + x; \ + } +#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace)) #define emberAfZllCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer)) #else #define emberAfZllCommissioningClusterPrint(...) @@ -2013,17 +2538,21 @@ #define emberAfZllCommissioningClusterDebugExec(x) #define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) #define emberAfZllCommissioningClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) // Printing macros for cluster: Sample Mfg Specific Cluster #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) #define emberAfSampleMfgSpecificClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__) -#define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__) +#define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSampleMfgSpecificClusterFlush() -#define emberAfSampleMfgSpecificClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) ) { x; } -#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSampleMfgSpecificClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace)) #define emberAfSampleMfgSpecificClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer)) #else #define emberAfSampleMfgSpecificClusterPrint(...) @@ -2032,18 +2561,23 @@ #define emberAfSampleMfgSpecificClusterDebugExec(x) #define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) #define emberAfSampleMfgSpecificClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) // Printing macros for cluster: Sample Mfg Specific Cluster 2 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) #define emberAfSampleMfgSpecificCluster2Print(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__) -#define emberAfSampleMfgSpecificCluster2Println(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__) +#define emberAfSampleMfgSpecificCluster2Println(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSampleMfgSpecificCluster2Flush() -#define emberAfSampleMfgSpecificCluster2DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) ) { x; } -#define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer), (len), (withSpace)) -#define emberAfSampleMfgSpecificCluster2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer)) +#define emberAfSampleMfgSpecificCluster2DebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2)) \ + { \ + x; \ + } +#define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer), (len), (withSpace)) +#define emberAfSampleMfgSpecificCluster2PrintString(buffer) \ + emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer)) #else #define emberAfSampleMfgSpecificCluster2Print(...) #define emberAfSampleMfgSpecificCluster2Println(...) @@ -2051,17 +2585,21 @@ #define emberAfSampleMfgSpecificCluster2DebugExec(x) #define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace) #define emberAfSampleMfgSpecificCluster2PrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2) // Printing macros for cluster: Configuration Cluster #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) #define emberAfOtaConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__) -#define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__) +#define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfOtaConfigurationClusterFlush() -#define emberAfOtaConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) ) { x; } -#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfOtaConfigurationClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)) \ + { \ + x; \ + } +#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace)) #define emberAfOtaConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer)) #else #define emberAfOtaConfigurationClusterPrint(...) @@ -2070,17 +2608,21 @@ #define emberAfOtaConfigurationClusterDebugExec(x) #define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) #define emberAfOtaConfigurationClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) // Printing macros for cluster: MFGLIB Cluster #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER) #define emberAfMfglibClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__) -#define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__) +#define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfMfglibClusterFlush() -#define emberAfMfglibClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER) ) { x; } -#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfMfglibClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER)) \ + { \ + x; \ + } +#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace)) #define emberAfMfglibClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer)) #else #define emberAfMfglibClusterPrint(...) @@ -2089,17 +2631,21 @@ #define emberAfMfglibClusterDebugExec(x) #define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) #define emberAfMfglibClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER) // Printing macros for cluster: SL Works With All Hubs #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER) #define emberAfSlWwahClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__) -#define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__) +#define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSlWwahClusterFlush() -#define emberAfSlWwahClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER) ) { x; } -#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace)) +#define emberAfSlWwahClusterDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER)) \ + { \ + x; \ + } +#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace)) #define emberAfSlWwahClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer)) #else #define emberAfSlWwahClusterPrint(...) @@ -2108,17 +2654,20 @@ #define emberAfSlWwahClusterDebugExec(x) #define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) #define emberAfSlWwahClusterPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER) // Printing macros for Core // Prints messages for global flow of the receive/send #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE) #define emberAfCorePrint(...) emberAfPrint(EMBER_AF_PRINT_CORE, __VA_ARGS__) -#define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE, __VA_ARGS__) +#define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCoreFlush() -#define emberAfCoreDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CORE) ) { x; } +#define emberAfCoreDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CORE)) \ + { \ + x; \ + } #define emberAfCorePrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CORE, (buffer), (len), (withSpace)) #define emberAfCorePrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CORE, (buffer)) #else @@ -2128,17 +2677,20 @@ #define emberAfCoreDebugExec(x) #define emberAfCorePrintBuffer(buffer, len, withSpace) #define emberAfCorePrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE) // Printing macros for Debug // Prints messages for random debugging #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG) #define emberAfDebugPrint(...) emberAfPrint(EMBER_AF_PRINT_DEBUG, __VA_ARGS__) -#define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG, __VA_ARGS__) +#define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfDebugFlush() -#define emberAfDebugDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG) ) { x; } +#define emberAfDebugDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG)) \ + { \ + x; \ + } #define emberAfDebugPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEBUG, (buffer), (len), (withSpace)) #define emberAfDebugPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEBUG, (buffer)) #else @@ -2148,17 +2700,20 @@ #define emberAfDebugDebugExec(x) #define emberAfDebugPrintBuffer(buffer, len, withSpace) #define emberAfDebugPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG) // Printing macros for Application // Prints messages for application part #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) #define emberAfAppPrint(...) emberAfPrint(EMBER_AF_PRINT_APP, __VA_ARGS__) -#define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP, __VA_ARGS__) +#define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfAppFlush() -#define emberAfAppDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APP) ) { x; } +#define emberAfAppDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_APP)) \ + { \ + x; \ + } #define emberAfAppPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APP, (buffer), (len), (withSpace)) #define emberAfAppPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APP, (buffer)) #else @@ -2168,17 +2723,20 @@ #define emberAfAppDebugExec(x) #define emberAfAppPrintBuffer(buffer, len, withSpace) #define emberAfAppPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) // Printing macros for Security // Prints messages related to security #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY) #define emberAfSecurityPrint(...) emberAfPrint(EMBER_AF_PRINT_SECURITY, __VA_ARGS__) -#define emberAfSecurityPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SECURITY, __VA_ARGS__) +#define emberAfSecurityPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SECURITY, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfSecurityFlush() -#define emberAfSecurityDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SECURITY) ) { x; } +#define emberAfSecurityDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SECURITY)) \ + { \ + x; \ + } #define emberAfSecurityPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SECURITY, (buffer), (len), (withSpace)) #define emberAfSecurityPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SECURITY, (buffer)) #else @@ -2188,18 +2746,22 @@ #define emberAfSecurityDebugExec(x) #define emberAfSecurityPrintBuffer(buffer, len, withSpace) #define emberAfSecurityPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY) // Printing macros for Attributes // Prints messages related to attributes #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) #define emberAfAttributesPrint(...) emberAfPrint(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__) -#define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__) +#define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfAttributesFlush() -#define emberAfAttributesDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES) ) { x; } -#define emberAfAttributesPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace)) +#define emberAfAttributesDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES)) \ + { \ + x; \ + } +#define emberAfAttributesPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace)) #define emberAfAttributesPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ATTRIBUTES, (buffer)) #else #define emberAfAttributesPrint(...) @@ -2208,18 +2770,22 @@ #define emberAfAttributesDebugExec(x) #define emberAfAttributesPrintBuffer(buffer, len, withSpace) #define emberAfAttributesPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES) // Printing macros for Reporting // Prints messages related to reporting #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING) #define emberAfReportingPrint(...) emberAfPrint(EMBER_AF_PRINT_REPORTING, __VA_ARGS__) -#define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING, __VA_ARGS__) +#define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfReportingFlush() -#define emberAfReportingDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING) ) { x; } -#define emberAfReportingPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace)) +#define emberAfReportingDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING)) \ + { \ + x; \ + } +#define emberAfReportingPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace)) #define emberAfReportingPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REPORTING, (buffer)) #else #define emberAfReportingPrint(...) @@ -2228,18 +2794,22 @@ #define emberAfReportingDebugExec(x) #define emberAfReportingPrintBuffer(buffer, len, withSpace) #define emberAfReportingPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING) // Printing macros for Service discovery // Prints messages related to service discovery #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY) #define emberAfServiceDiscoveryPrint(...) emberAfPrint(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__) -#define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__) +#define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfServiceDiscoveryFlush() -#define emberAfServiceDiscoveryDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY) ) { x; } -#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace)) +#define emberAfServiceDiscoveryDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY)) \ + { \ + x; \ + } +#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace)) #define emberAfServiceDiscoveryPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer)) #else #define emberAfServiceDiscoveryPrint(...) @@ -2248,18 +2818,22 @@ #define emberAfServiceDiscoveryDebugExec(x) #define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) #define emberAfServiceDiscoveryPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY) // Printing macros for Registration // Prints messages related to registration #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION) #define emberAfRegistrationPrint(...) emberAfPrint(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__) -#define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__) +#define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfRegistrationFlush() -#define emberAfRegistrationDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION) ) { x; } -#define emberAfRegistrationPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace)) +#define emberAfRegistrationDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION)) \ + { \ + x; \ + } +#define emberAfRegistrationPrintBuffer(buffer, len, withSpace) \ + emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace)) #define emberAfRegistrationPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REGISTRATION, (buffer)) #else #define emberAfRegistrationPrint(...) @@ -2268,17 +2842,20 @@ #define emberAfRegistrationDebugExec(x) #define emberAfRegistrationPrintBuffer(buffer, len, withSpace) #define emberAfRegistrationPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION) // Printing macros for ZDO (ZigBee Device Object) // Prints messages related to ZDO functionality #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO) #define emberAfZdoPrint(...) emberAfPrint(EMBER_AF_PRINT_ZDO, __VA_ARGS__) -#define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO, __VA_ARGS__) +#define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfZdoFlush() -#define emberAfZdoDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZDO) ) { x; } +#define emberAfZdoDebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_ZDO)) \ + { \ + x; \ + } #define emberAfZdoPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZDO, (buffer), (len), (withSpace)) #define emberAfZdoPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZDO, (buffer)) #else @@ -2288,17 +2865,20 @@ #define emberAfZdoDebugExec(x) #define emberAfZdoPrintBuffer(buffer, len, withSpace) #define emberAfZdoPrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO) // Printing macros for Custom messages (1) // Messages that can be used by the end developer #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1) #define emberAfCustom1Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__) -#define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__) +#define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCustom1Flush() -#define emberAfCustom1DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1) ) { x; } +#define emberAfCustom1DebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1)) \ + { \ + x; \ + } #define emberAfCustom1PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM1, (buffer), (len), (withSpace)) #define emberAfCustom1PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM1, (buffer)) #else @@ -2308,17 +2888,20 @@ #define emberAfCustom1DebugExec(x) #define emberAfCustom1PrintBuffer(buffer, len, withSpace) #define emberAfCustom1PrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1) // Printing macros for Custom messages (2) // Messages that can be used by the end developer #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2) #define emberAfCustom2Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__) -#define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__) +#define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCustom2Flush() -#define emberAfCustom2DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2) ) { x; } +#define emberAfCustom2DebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2)) \ + { \ + x; \ + } #define emberAfCustom2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM2, (buffer), (len), (withSpace)) #define emberAfCustom2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM2, (buffer)) #else @@ -2328,17 +2911,20 @@ #define emberAfCustom2DebugExec(x) #define emberAfCustom2PrintBuffer(buffer, len, withSpace) #define emberAfCustom2PrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2) // Printing macros for Custom messages (3) // Messages that can be used by the end developer #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3) #define emberAfCustom3Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__) -#define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__) +#define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__) // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary. #define emberAfCustom3Flush() -#define emberAfCustom3DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3) ) { x; } +#define emberAfCustom3DebugExec(x) \ + if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3)) \ + { \ + x; \ + } #define emberAfCustom3PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM3, (buffer), (len), (withSpace)) #define emberAfCustom3PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM3, (buffer)) #else @@ -2348,7 +2934,6 @@ #define emberAfCustom3DebugExec(x) #define emberAfCustom3PrintBuffer(buffer, len, withSpace) #define emberAfCustom3PrintString(buffer) -#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3) - +#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3) #endif // SILABS_EMBER_AF_DEBUG_PRINTING diff --git a/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h b/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h index 23f6f25abafb14..70c37bde9d2ec9 100644 --- a/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h +++ b/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h @@ -39,49 +39,51 @@ #ifndef SILABS_AF_ENDPOINT_CONFIG #define SILABS_AF_ENDPOINT_CONFIG - // Fixed number of defined endpoints #define FIXED_ENDPOINT_COUNT (1) - - - // Generated attributes -#define GENERATED_ATTRIBUTES { \ - { 0x0000, ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, (0x00), { (uint8_t*)0x00 } }, /* 0 / On/off / on/off*/\ - { 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t*)0x0001 } }, /* 1 / On/off / cluster revision*/\ - } - +#define GENERATED_ATTRIBUTES \ + { \ + { 0x0000, ZCL_BOOLEAN_ATTRIBUTE_TYPE, 1, (0x00), { (uint8_t *) 0x00 } }, /* 0 / On/off / on/off*/ \ + { 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t *) 0x0001 } }, /* 1 / On/off / cluster revision*/ \ + } // Cluster function static arrays -#define GENERATED_FUNCTION_ARRAYS \ - +#define GENERATED_FUNCTION_ARRAYS // Clusters definitions -#define GENERATED_CLUSTERS { \ - { 0x0006, (EmberAfAttributeMetadata*)&(generatedAttributes[0]), 2, 3, (CLUSTER_MASK_SERVER), NULL, }, \ - } - +#define GENERATED_CLUSTERS \ + { \ + { \ + 0x0006, (EmberAfAttributeMetadata *) &(generatedAttributes[0]), 2, 3, (CLUSTER_MASK_SERVER), NULL, \ + }, \ + } // Endpoint types -#define GENERATED_ENDPOINT_TYPES { \ - { (EmberAfCluster*)&(generatedClusters[0]), 1, 3 }, \ - } - +#define GENERATED_ENDPOINT_TYPES \ + { \ + { (EmberAfCluster *) &(generatedClusters[0]), 1, 3 }, \ + } // Cluster manufacturer codes -#define GENERATED_CLUSTER_MANUFACTURER_CODES { \ -{0x00, 0x00} \ - } +#define GENERATED_CLUSTER_MANUFACTURER_CODES \ + { \ + { \ + 0x00, 0x00 \ + } \ + } #define GENERATED_CLUSTER_MANUFACTURER_CODE_COUNT (0) // Attribute manufacturer codes -#define GENERATED_ATTRIBUTE_MANUFACTURER_CODES { \ -{0x00, 0x00} \ - } +#define GENERATED_ATTRIBUTE_MANUFACTURER_CODES \ + { \ + { \ + 0x00, 0x00 \ + } \ + } #define GENERATED_ATTRIBUTE_MANUFACTURER_CODE_COUNT (0) - // Largest attribute size is needed for various buffers #define ATTRIBUTE_LARGEST (2) // Total size of singleton attributes @@ -91,50 +93,68 @@ #define ATTRIBUTE_MAX_SIZE 3 // Array of endpoints that are supported -#define FIXED_ENDPOINT_ARRAY { 1 } +#define FIXED_ENDPOINT_ARRAY \ + { \ + 1 \ + } // Array of profile ids -#define FIXED_PROFILE_IDS { 65535 } +#define FIXED_PROFILE_IDS \ + { \ + 65535 \ + } // Array of device ids -#define FIXED_DEVICE_IDS { 65535 } +#define FIXED_DEVICE_IDS \ + { \ + 65535 \ + } // Array of device versions -#define FIXED_DEVICE_VERSIONS { 1 } +#define FIXED_DEVICE_VERSIONS \ + { \ + 1 \ + } // Array of endpoint types supported on each endpoint -#define FIXED_ENDPOINT_TYPES { 0 } +#define FIXED_ENDPOINT_TYPES \ + { \ + 0 \ + } // Array of networks supported on each endpoint -#define FIXED_NETWORKS { 0 } - +#define FIXED_NETWORKS \ + { \ + 0 \ + } -#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_DECLARATIONS \ - void emberAfPluginNetworkSteeringStackStatusCallback(EmberStatus status); \ - - -#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_CALLS \ - emberAfPluginNetworkSteeringStackStatusCallback(status); \ +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_DECLARATIONS \ + void emberAfPluginNetworkSteeringStackStatusCallback(EmberStatus status); +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_CALLS emberAfPluginNetworkSteeringStackStatusCallback(status); // Generated data for the command discovery -#define GENERATED_COMMANDS { \ - { 0x0006, 0x00, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Off */ \ - { 0x0006, 0x01, COMMAND_MASK_INCOMING_SERVER }, /* On/off / On */ \ - { 0x0006, 0x02, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Toggle */ \ - } +#define GENERATED_COMMANDS \ + { \ + { 0x0006, 0x00, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Off */ \ + { 0x0006, 0x01, COMMAND_MASK_INCOMING_SERVER }, /* On/off / On */ \ + { 0x0006, 0x02, COMMAND_MASK_INCOMING_SERVER }, /* On/off / Toggle */ \ + } #define EMBER_AF_GENERATED_COMMAND_COUNT (3) // Command manufacturer codes -#define GENERATED_COMMAND_MANUFACTURER_CODES { \ -{0x00, 0x00} \ - } +#define GENERATED_COMMAND_MANUFACTURER_CODES \ + { \ + { \ + 0x00, 0x00 \ + } \ + } #define GENERATED_COMMAND_MANUFACTURER_CODE_COUNT (0) - // Generated reporting configuration defaults -#define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS {\ - { EMBER_ZCL_REPORTING_DIRECTION_REPORTED, 1, 0x0006, 0x0000, CLUSTER_MASK_SERVER, 0x0000, 1, 65534, 0 }, \ -} +#define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS \ + { \ + { EMBER_ZCL_REPORTING_DIRECTION_REPORTED, 1, 0x0006, 0x0000, CLUSTER_MASK_SERVER, 0x0000, 1, 65534, 0 }, \ + } #define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS_TABLE_SIZE (1) #endif // SILABS_AF_ENDPOINT_CONFIG diff --git a/examples/wifi-echo/server/esp32/main/gen/enums.h b/examples/wifi-echo/server/esp32/main/gen/enums.h index 5d0011b9df4802..c1881b3732b9e3 100644 --- a/examples/wifi-echo/server/esp32/main/gen/enums.h +++ b/examples/wifi-echo/server/esp32/main/gen/enums.h @@ -39,7 +39,6 @@ #ifndef SILABS_EMBER_AF_ENUMS #define SILABS_EMBER_AF_ENUMS - /** * @addtogroup enums Application Framework Enums Reference * This header provides Application Framework enum definitions. @@ -48,2164 +47,2370 @@ /** @name Enums */ // @{ -typedef enum { - EMBER_ZCL_11073_CONNECT_REQUEST_CONNECT_CONTROL_PREEMPTIBLE = 0x01, +typedef enum +{ + EMBER_ZCL_11073_CONNECT_REQUEST_CONNECT_CONTROL_PREEMPTIBLE = 0x01, } EmberAf11073ConnectRequestConnectControl; -typedef enum { - EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_DISCONNECTED = 0x00, - EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_CONNECTED = 0x01, - EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_NOT_AUTHORIZED = 0x02, - EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_RECONNECT_REQUEST = 0x03, - EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_ALREADY_CONNECTED = 0x04, +typedef enum +{ + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_DISCONNECTED = 0x00, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_CONNECTED = 0x01, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_NOT_AUTHORIZED = 0x02, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_RECONNECT_REQUEST = 0x03, + EMBER_ZCL_11073_TUNNEL_CONNECTION_STATUS_ALREADY_CONNECTED = 0x04, } EmberAf11073TunnelConnectionStatus; -typedef enum { - EMBER_ZCL_ALERT_COUNT_TYPE_UNSTRUCTURED = 0x00, +typedef enum +{ + EMBER_ZCL_ALERT_COUNT_TYPE_UNSTRUCTURED = 0x00, } EmberAfAlertCountType; -typedef enum { - EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_WARNING = 0x0100, - EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_DANGER = 0x0200, - EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_FAILURE = 0x0300, +typedef enum +{ + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_WARNING = 0x0100, + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_DANGER = 0x0200, + EMBER_ZCL_ALERT_STRUCTURE_CATEGORY_FAILURE = 0x0300, } EmberAfAlertStructureCategory; -typedef enum { - EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_RECOVERY = 0x0000, - EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_PRESENCE = 0x1000, +typedef enum +{ + EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_RECOVERY = 0x0000, + EMBER_ZCL_ALERT_STRUCTURE_PRESENCE_RECOVERY_PRESENCE = 0x1000, } EmberAfAlertStructurePresenceRecovery; -typedef enum { - EMBER_ZCL_ALTERNATE_COST_UNIT_KG_OF_CO2_PER_UNIT_OF_MEASURE = 0x02, +typedef enum +{ + EMBER_ZCL_ALTERNATE_COST_UNIT_KG_OF_CO2_PER_UNIT_OF_MEASURE = 0x02, } EmberAfAlternateCostUnit; -typedef enum { - EMBER_ZCL_AMI_CRITICALITY_LEVEL_RESERVED = 0x00, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_GREEN = 0x01, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_1 = 0x02, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_2 = 0x03, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_3 = 0x04, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_4 = 0x05, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_5 = 0x06, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_EMERGENCY = 0x07, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_PLANNED_OUTAGE = 0x08, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_SERVICE_DISCONNECT = 0x09, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED1 = 0x0A, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED2 = 0x0B, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED3 = 0x0C, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED4 = 0x0D, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED5 = 0x0E, - EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED6 = 0x0F, +typedef enum +{ + EMBER_ZCL_AMI_CRITICALITY_LEVEL_RESERVED = 0x00, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_GREEN = 0x01, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_1 = 0x02, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_2 = 0x03, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_3 = 0x04, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_4 = 0x05, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_5 = 0x06, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_EMERGENCY = 0x07, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_PLANNED_OUTAGE = 0x08, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_SERVICE_DISCONNECT = 0x09, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED1 = 0x0A, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED2 = 0x0B, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED3 = 0x0C, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED4 = 0x0D, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED5 = 0x0E, + EMBER_ZCL_AMI_CRITICALITY_LEVEL_UTILITY_DEFINED6 = 0x0F, } EmberAfAmiCriticalityLevel; -typedef enum { - EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_RX = 0x01, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_STARTED = 0x02, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED = 0x03, - EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_OUT = 0x04, - EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_IN = 0x05, - EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_CANCELED = 0x06, - EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_SUPERSEDED = 0x07, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_WITH_USER_OPT_OUT = 0x08, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_DUE_TO_USER_OPT_IN = 0x09, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED_NO_USER_PARTICIPATION_PREVIOUS_OPT_OUT = 0x0A, - EMBER_ZCL_AMI_EVENT_STATUS_INVALID_OPT_OUT = 0xF6, - EMBER_ZCL_AMI_EVENT_STATUS_EVENT_NOT_FOUND = 0xF7, - EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND = 0xF8, - EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND_INVALID_EFFECTIVE_TIME = 0xF9, - EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_EVENT_EXPIRED = 0xFB, - EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_UNDEFINED_EVENT = 0xFD, - EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_REJECTED = 0xFE, +typedef enum +{ + EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_RX = 0x01, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_STARTED = 0x02, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED = 0x03, + EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_OUT = 0x04, + EMBER_ZCL_AMI_EVENT_STATUS_USER_HAS_CHOOSE_TO_OPT_IN = 0x05, + EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_CANCELED = 0x06, + EMBER_ZCL_AMI_EVENT_STATUS_THE_EVENT_HAS_BEEN_SUPERSEDED = 0x07, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_WITH_USER_OPT_OUT = 0x08, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_PARTIALLY_COMPLETED_DUE_TO_USER_OPT_IN = 0x09, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_COMPLETED_NO_USER_PARTICIPATION_PREVIOUS_OPT_OUT = 0x0A, + EMBER_ZCL_AMI_EVENT_STATUS_INVALID_OPT_OUT = 0xF6, + EMBER_ZCL_AMI_EVENT_STATUS_EVENT_NOT_FOUND = 0xF7, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND = 0xF8, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_COMMAND_INVALID_EFFECTIVE_TIME = 0xF9, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_EVENT_EXPIRED = 0xFB, + EMBER_ZCL_AMI_EVENT_STATUS_REJECTED_INVALID_CANCEL_UNDEFINED_EVENT = 0xFD, + EMBER_ZCL_AMI_EVENT_STATUS_LOAD_CONTROL_EVENT_COMMAND_REJECTED = 0xFE, } EmberAfAmiEventStatus; -typedef enum { - EMBER_ZCL_AMI_GET_PROFILE_STATUS_SUCCESS = 0x00, - EMBER_ZCL_AMI_GET_PROFILE_STATUS_UNDEFINED_INTERVAL_CHANNEL_REQUESTED = 0x01, - EMBER_ZCL_AMI_GET_PROFILE_STATUS_INTERVAL_CHANNEL_NOT_SUPPORTED = 0x02, - EMBER_ZCL_AMI_GET_PROFILE_STATUS_INVALID_END_TIME = 0x03, - EMBER_ZCL_AMI_GET_PROFILE_STATUS_MORE_PERIODS_REQUESTED_THAN_CAN_BE_RETURNED = 0x04, - EMBER_ZCL_AMI_GET_PROFILE_STATUS_NO_INTERVALS_AVAILABLE_FOR_THE_REQUESTED_TIME = 0x05, +typedef enum +{ + EMBER_ZCL_AMI_GET_PROFILE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_UNDEFINED_INTERVAL_CHANNEL_REQUESTED = 0x01, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_INTERVAL_CHANNEL_NOT_SUPPORTED = 0x02, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_INVALID_END_TIME = 0x03, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_MORE_PERIODS_REQUESTED_THAN_CAN_BE_RETURNED = 0x04, + EMBER_ZCL_AMI_GET_PROFILE_STATUS_NO_INTERVALS_AVAILABLE_FOR_THE_REQUESTED_TIME = 0x05, } EmberAfAmiGetProfileStatus; -typedef enum { - EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_DELIVERED = 0x00, - EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_RECEIVED = 0x01, +typedef enum +{ + EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_DELIVERED = 0x00, + EMBER_ZCL_AMI_INTERVAL_CHANNEL_CONSUMPTION_RECEIVED = 0x01, } EmberAfAmiIntervalChannel; -typedef enum { - EMBER_ZCL_AMI_INTERVAL_PERIOD_DAILY = 0x00, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES60 = 0x01, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES30 = 0x02, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES15 = 0x03, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES10 = 0x04, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES7P5 = 0x05, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES5 = 0x06, - EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES2P5 = 0x07, +typedef enum +{ + EMBER_ZCL_AMI_INTERVAL_PERIOD_DAILY = 0x00, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES60 = 0x01, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES30 = 0x02, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES15 = 0x03, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES10 = 0x04, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES7P5 = 0x05, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES5 = 0x06, + EMBER_ZCL_AMI_INTERVAL_PERIOD_MINUTES2P5 = 0x07, } EmberAfAmiIntervalPeriod; -typedef enum { - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_SUCCESS = 0x00, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNKNOWN_ISSUER = 0x01, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_KEY_CONFIRM = 0x02, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_MESSAGE = 0x03, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_NO_RESOURCES = 0x04, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNSUPPORTED_SUITE = 0x05, - EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_INVALID_KEY_USAGE = 0x06, +typedef enum +{ + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_SUCCESS = 0x00, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNKNOWN_ISSUER = 0x01, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_KEY_CONFIRM = 0x02, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_BAD_MESSAGE = 0x03, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_NO_RESOURCES = 0x04, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_UNSUPPORTED_SUITE = 0x05, + EMBER_ZCL_AMI_KEY_ESTABLISHMENT_STATUS_INVALID_KEY_USAGE = 0x06, } EmberAfAmiKeyEstablishmentStatus; -typedef enum { - EMBER_ZCL_AMI_REGISTRATION_STATE_UNREGISTERED = 0x00, - EMBER_ZCL_AMI_REGISTRATION_STATE_JOINING_NETWORK = 0x01, - EMBER_ZCL_AMI_REGISTRATION_STATE_JOINED_NETWORK = 0x02, - EMBER_ZCL_AMI_REGISTRATION_STATE_SUBMITTED_REGISTRATION_REQUEST = 0x03, - EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTRATION_REJECTED = 0x04, - EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERED = 0x05, - EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERATION_NOT_POSSIBLE = 0x06, +typedef enum +{ + EMBER_ZCL_AMI_REGISTRATION_STATE_UNREGISTERED = 0x00, + EMBER_ZCL_AMI_REGISTRATION_STATE_JOINING_NETWORK = 0x01, + EMBER_ZCL_AMI_REGISTRATION_STATE_JOINED_NETWORK = 0x02, + EMBER_ZCL_AMI_REGISTRATION_STATE_SUBMITTED_REGISTRATION_REQUEST = 0x03, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTRATION_REJECTED = 0x04, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERED = 0x05, + EMBER_ZCL_AMI_REGISTRATION_STATE_REGISTERATION_NOT_POSSIBLE = 0x06, } EmberAfAmiRegistrationState; -typedef enum { - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS = 0x00, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR = 0x01, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR = 0x02, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR = 0x03, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR = 0x04, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR = 0x05, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR = 0x06, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR = 0x07, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GAUGE = 0x08, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE = 0x09, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND = 0x0A, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS = 0x0B, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND = 0x0C, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS = 0x0D, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS_BCD = 0x80, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR_BCD = 0x81, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR_BCD = 0x82, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR_BCD = 0x83, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR_BCD = 0x84, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR_BCD = 0x85, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR_BCD = 0x86, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR_BCD = 0x87, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GUAGE_BCD = 0x88, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE_BCD = 0x89, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND_BCD = 0x8A, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS_BCD = 0x8B, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND_BCD = 0x8C, - EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS_BCD = 0x8D, +typedef enum +{ + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS = 0x00, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR = 0x01, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR = 0x02, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR = 0x03, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR = 0x04, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR = 0x05, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR = 0x06, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR = 0x07, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GAUGE = 0x08, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE = 0x09, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND = 0x0A, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS = 0x0B, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND = 0x0C, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS = 0x0D, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KILO_WATT_HOURS_BCD = 0x80, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_METER_PER_HOUR_BCD = 0x81, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CUBIC_FEET_PER_HOUR_BCD = 0x82, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_CENTUM_CUBIC_FEET_PER_HOUR_BCD = 0x83, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_US_GALLONS_PER_HOUR_BCD = 0x84, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_IMPERIAL_GALLONS_PER_HOUR_BCD = 0x85, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_BT_US_OR_BTU_PER_HOUR_BCD = 0x86, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_LITERS_OR_LITERS_PER_HOUR_BCD = 0x87, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_GUAGE_BCD = 0x88, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_KPA_ABSOLUTE_BCD = 0x89, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MCF_OR_MCF_PER_SECOND_BCD = 0x8A, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_UNITLESS_BCD = 0x8B, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_MJ_OR_MJ_PER_SECOND_BCD = 0x8C, + EMBER_ZCL_AMI_UNIT_OF_MEASURE_K_VAR_OR_K_VAR_HOURS_BCD = 0x8D, } EmberAfAmiUnitOfMeasure; -typedef enum { - EMBER_ZCL_ANONYMOUS_DATA_STATE_NO_SOURCE_FOUND = 0x00, - EMBER_ZCL_ANONYMOUS_DATA_STATE_SOURCE_FOUND = 0x01, +typedef enum +{ + EMBER_ZCL_ANONYMOUS_DATA_STATE_NO_SOURCE_FOUND = 0x00, + EMBER_ZCL_ANONYMOUS_DATA_STATE_SOURCE_FOUND = 0x01, } EmberAfAnonymousDataState; -typedef enum { - EMBER_ZCL_APPLIANCE_STATUS_OFF = 0x01, - EMBER_ZCL_APPLIANCE_STATUS_STAND_BY = 0x02, - EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED = 0x03, - EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED_WAITING_TO_START = 0x04, - EMBER_ZCL_APPLIANCE_STATUS_RUNNING = 0x05, - EMBER_ZCL_APPLIANCE_STATUS_PAUSE = 0x06, - EMBER_ZCL_APPLIANCE_STATUS_END_PROGRAMMED = 0x07, - EMBER_ZCL_APPLIANCE_STATUS_FAILURE = 0x08, - EMBER_ZCL_APPLIANCE_STATUS_PROGRAMME_INTERRUPTED = 0x09, - EMBER_ZCL_APPLIANCE_STATUS_IDLE = 0x0A, - EMBER_ZCL_APPLIANCE_STATUS_RINSE_HOLD = 0x0B, - EMBER_ZCL_APPLIANCE_STATUS_SERVICE = 0x0C, - EMBER_ZCL_APPLIANCE_STATUS_SUPERFREEZING = 0x0D, - EMBER_ZCL_APPLIANCE_STATUS_SUPERCOOLING = 0x0E, - EMBER_ZCL_APPLIANCE_STATUS_SUPERHEATING = 0x0F, +typedef enum +{ + EMBER_ZCL_APPLIANCE_STATUS_OFF = 0x01, + EMBER_ZCL_APPLIANCE_STATUS_STAND_BY = 0x02, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED = 0x03, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMMED_WAITING_TO_START = 0x04, + EMBER_ZCL_APPLIANCE_STATUS_RUNNING = 0x05, + EMBER_ZCL_APPLIANCE_STATUS_PAUSE = 0x06, + EMBER_ZCL_APPLIANCE_STATUS_END_PROGRAMMED = 0x07, + EMBER_ZCL_APPLIANCE_STATUS_FAILURE = 0x08, + EMBER_ZCL_APPLIANCE_STATUS_PROGRAMME_INTERRUPTED = 0x09, + EMBER_ZCL_APPLIANCE_STATUS_IDLE = 0x0A, + EMBER_ZCL_APPLIANCE_STATUS_RINSE_HOLD = 0x0B, + EMBER_ZCL_APPLIANCE_STATUS_SERVICE = 0x0C, + EMBER_ZCL_APPLIANCE_STATUS_SUPERFREEZING = 0x0D, + EMBER_ZCL_APPLIANCE_STATUS_SUPERCOOLING = 0x0E, + EMBER_ZCL_APPLIANCE_STATUS_SUPERHEATING = 0x0F, } EmberAfApplianceStatus; -typedef enum { - EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_PENDING = 0x00, - EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_ATTRIBUTE_REPORTING_COMPLETE = 0x01, +typedef enum +{ + EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_PENDING = 0x00, + EMBER_ZCL_ATTRIBUTE_REPORTING_STATUS_ATTRIBUTE_REPORTING_COMPLETE = 0x01, } EmberAfAttributeReportingStatus; -typedef enum { - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_DENY_WRITE = 0x00, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL = 0x01, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY = 0x02, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_UNSUPPORTED_ATTRIBUTE = 0x86, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_VALUE = 0x87, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_READ_ONLY = 0x88, - EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_DATA_TYPE = 0x8D, +typedef enum +{ + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_DENY_WRITE = 0x00, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_NORMAL = 0x01, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_ALLOW_WRITE_OF_READ_ONLY = 0x02, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_UNSUPPORTED_ATTRIBUTE = 0x86, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_VALUE = 0x87, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_READ_ONLY = 0x88, + EMBER_ZCL_ATTRIBUTE_WRITE_PERMISSION_INVALID_DATA_TYPE = 0x8D, } EmberAfAttributeWritePermission; -typedef enum { - EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_CLOSED = 0x00, - EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_OPEN = 0x64, - EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_UNKNOWN = 0xFF, +typedef enum +{ + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_CLOSED = 0x00, + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_OPEN = 0x64, + EMBER_ZCL_BARRIER_CONTROL_BARRIER_POSITION_UNKNOWN = 0xFF, } EmberAfBarrierControlBarrierPosition; -typedef enum { - EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_STOPPED = 0x00, - EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_CLOSING = 0x01, - EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_OPENING = 0x02, +typedef enum +{ + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_STOPPED = 0x00, + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_CLOSING = 0x01, + EMBER_ZCL_BARRIER_CONTROL_MOVING_STATE_OPENING = 0x02, } EmberAfBarrierControlMovingState; -typedef enum { - EMBER_ZCL_BATTERY_SIZE_NO_BATTERY = 0x00, - EMBER_ZCL_BATTERY_SIZE_BUILT_IN = 0x01, - EMBER_ZCL_BATTERY_SIZE_OTHER = 0x02, - EMBER_ZCL_BATTERY_SIZE_AA = 0x03, - EMBER_ZCL_BATTERY_SIZE_AAA = 0x04, - EMBER_ZCL_BATTERY_SIZE_C = 0x05, - EMBER_ZCL_BATTERY_SIZE_D = 0x06, - EMBER_ZCL_BATTERY_SIZE_UNKNOWN = 0xFF, +typedef enum +{ + EMBER_ZCL_BATTERY_SIZE_NO_BATTERY = 0x00, + EMBER_ZCL_BATTERY_SIZE_BUILT_IN = 0x01, + EMBER_ZCL_BATTERY_SIZE_OTHER = 0x02, + EMBER_ZCL_BATTERY_SIZE_AA = 0x03, + EMBER_ZCL_BATTERY_SIZE_AAA = 0x04, + EMBER_ZCL_BATTERY_SIZE_C = 0x05, + EMBER_ZCL_BATTERY_SIZE_D = 0x06, + EMBER_ZCL_BATTERY_SIZE_UNKNOWN = 0xFF, } EmberAfBatterySize; -typedef enum { - EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MINUTES = 0x000000, - EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_DAYS = 0x400000, - EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_WEEKS = 0x800000, - EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MONTHS = 0xC00000, +typedef enum +{ + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MINUTES = 0x000000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_DAYS = 0x400000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_WEEKS = 0x800000, + EMBER_ZCL_BILLING_PERIOD_DURATION_UNITS_MONTHS = 0xC00000, } EmberAfBillingPeriodDurationUnits; -typedef enum { - EMBER_ZCL_BLOCK_NO_BLOCKS_IN_USE = 0x00, - EMBER_ZCL_BLOCK_BLOCK1 = 0x01, - EMBER_ZCL_BLOCK_BLOCK2 = 0x02, - EMBER_ZCL_BLOCK_BLOCK3 = 0x03, - EMBER_ZCL_BLOCK_BLOCK4 = 0x04, - EMBER_ZCL_BLOCK_BLOCK5 = 0x05, - EMBER_ZCL_BLOCK_BLOCK6 = 0x06, - EMBER_ZCL_BLOCK_BLOCK7 = 0x07, - EMBER_ZCL_BLOCK_BLOCK8 = 0x08, - EMBER_ZCL_BLOCK_BLOCK9 = 0x09, - EMBER_ZCL_BLOCK_BLOCK10 = 0x0A, - EMBER_ZCL_BLOCK_BLOCK11 = 0x0B, - EMBER_ZCL_BLOCK_BLOCK12 = 0x0C, - EMBER_ZCL_BLOCK_BLOCK13 = 0x0D, - EMBER_ZCL_BLOCK_BLOCK14 = 0x0E, - EMBER_ZCL_BLOCK_BLOCK15 = 0x0F, - EMBER_ZCL_BLOCK_BLOCK16 = 0x10, +typedef enum +{ + EMBER_ZCL_BLOCK_NO_BLOCKS_IN_USE = 0x00, + EMBER_ZCL_BLOCK_BLOCK1 = 0x01, + EMBER_ZCL_BLOCK_BLOCK2 = 0x02, + EMBER_ZCL_BLOCK_BLOCK3 = 0x03, + EMBER_ZCL_BLOCK_BLOCK4 = 0x04, + EMBER_ZCL_BLOCK_BLOCK5 = 0x05, + EMBER_ZCL_BLOCK_BLOCK6 = 0x06, + EMBER_ZCL_BLOCK_BLOCK7 = 0x07, + EMBER_ZCL_BLOCK_BLOCK8 = 0x08, + EMBER_ZCL_BLOCK_BLOCK9 = 0x09, + EMBER_ZCL_BLOCK_BLOCK10 = 0x0A, + EMBER_ZCL_BLOCK_BLOCK11 = 0x0B, + EMBER_ZCL_BLOCK_BLOCK12 = 0x0C, + EMBER_ZCL_BLOCK_BLOCK13 = 0x0D, + EMBER_ZCL_BLOCK_BLOCK14 = 0x0E, + EMBER_ZCL_BLOCK_BLOCK15 = 0x0F, + EMBER_ZCL_BLOCK_BLOCK16 = 0x10, } EmberAfBlock; -typedef enum { - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_START_OF_TIMEBASE = 0x00, - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_END_OF_TIMEBASE = 0x10, - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_NOT_SPECIFIED = 0x20, +typedef enum +{ + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_START_OF_TIMEBASE = 0x00, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_END_OF_TIMEBASE = 0x10, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_CONTROL_NOT_SPECIFIED = 0x20, } EmberAfBlockPeriodDurationTypeControl; -typedef enum { - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MINUTES = 0x00, - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_DAYS = 0x01, - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_WEEKS = 0x02, - EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MONTHS = 0x03, +typedef enum +{ + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MINUTES = 0x00, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_DAYS = 0x01, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_WEEKS = 0x02, + EMBER_ZCL_BLOCK_PERIOD_DURATION_TYPE_TIMEBASE_MONTHS = 0x03, } EmberAfBlockPeriodDurationTypeTimebase; -typedef enum { - EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_KILOWATT_HOUR = 0x01, - EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_GALLON_OF_GASOLINE = 0x02, - EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_THERM_OF_NATURAL_GAS = 0x03, +typedef enum +{ + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_KILOWATT_HOUR = 0x01, + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_GALLON_OF_GASOLINE = 0x02, + EMBER_ZCL_C_O2_UNIT_KILOGRAM_PER_THERM_OF_NATURAL_GAS = 0x03, } EmberAfCO2Unit; -typedef enum { - EMBER_ZCL_CALENDAR_TIME_REFERENCE_UTC_TIME = 0x00, - EMBER_ZCL_CALENDAR_TIME_REFERENCE_STANDARD_TIME = 0x01, - EMBER_ZCL_CALENDAR_TIME_REFERENCE_LOCAL_TIME = 0x02, +typedef enum +{ + EMBER_ZCL_CALENDAR_TIME_REFERENCE_UTC_TIME = 0x00, + EMBER_ZCL_CALENDAR_TIME_REFERENCE_STANDARD_TIME = 0x01, + EMBER_ZCL_CALENDAR_TIME_REFERENCE_LOCAL_TIME = 0x02, } EmberAfCalendarTimeReference; -typedef enum { - EMBER_ZCL_CALENDAR_TYPE_DELIVERED_CALENDAR = 0x00, - EMBER_ZCL_CALENDAR_TYPE_RECEIVED_CALENDAR = 0x01, - EMBER_ZCL_CALENDAR_TYPE_DELIVERED_AND_RECEIVED_CALENDAR = 0x02, - EMBER_ZCL_CALENDAR_TYPE_FRIENDLY_CREDIT_CALENDAR = 0x03, - EMBER_ZCL_CALENDAR_TYPE_AUXILLIARY_LOAD_SWITCH_CALENDAR = 0x04, +typedef enum +{ + EMBER_ZCL_CALENDAR_TYPE_DELIVERED_CALENDAR = 0x00, + EMBER_ZCL_CALENDAR_TYPE_RECEIVED_CALENDAR = 0x01, + EMBER_ZCL_CALENDAR_TYPE_DELIVERED_AND_RECEIVED_CALENDAR = 0x02, + EMBER_ZCL_CALENDAR_TYPE_FRIENDLY_CREDIT_CALENDAR = 0x03, + EMBER_ZCL_CALENDAR_TYPE_AUXILLIARY_LOAD_SWITCH_CALENDAR = 0x04, } EmberAfCalendarType; -typedef enum { - EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_CUBIC_METER = 0x01, - EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_KILOGRAM = 0x02, +typedef enum +{ + EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_CUBIC_METER = 0x01, + EMBER_ZCL_CALORIFIC_VALUE_UNIT_MEGAJOULE_PER_KILOGRAM = 0x02, } EmberAfCalorificValueUnit; -typedef enum { - EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_NOT_CERTIFIED = 0x10, - EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_CERTIFIED = 0x1A, +typedef enum +{ + EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_NOT_CERTIFIED = 0x10, + EMBER_ZCL_CECED_SPECIFICATION_VERSION_COMPLIANT_WITH_V10_CERTIFIED = 0x1A, } EmberAfCecedSpecificationVersion; -typedef enum { - EMBER_ZCL_COLOR_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, +typedef enum +{ + EMBER_ZCL_COLOR_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, } EmberAfColorControlOptions; -typedef enum { - EMBER_ZCL_COLOR_LOOP_ACTION_DEACTIVATE = 0x00, - EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE = 0x01, - EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE = 0x02, +typedef enum +{ + EMBER_ZCL_COLOR_LOOP_ACTION_DEACTIVATE = 0x00, + EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE = 0x01, + EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE = 0x02, } EmberAfColorLoopAction; -typedef enum { - EMBER_ZCL_COLOR_LOOP_DIRECTION_DECREMENT_HUE = 0x00, - EMBER_ZCL_COLOR_LOOP_DIRECTION_INCREMENT_HUE = 0x01, +typedef enum +{ + EMBER_ZCL_COLOR_LOOP_DIRECTION_DECREMENT_HUE = 0x00, + EMBER_ZCL_COLOR_LOOP_DIRECTION_INCREMENT_HUE = 0x01, } EmberAfColorLoopDirection; -typedef enum { - EMBER_ZCL_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, - EMBER_ZCL_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, - EMBER_ZCL_COLOR_MODE_COLOR_TEMPERATURE = 0x02, +typedef enum +{ + EMBER_ZCL_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, + EMBER_ZCL_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, + EMBER_ZCL_COLOR_MODE_COLOR_TEMPERATURE = 0x02, } EmberAfColorMode; -typedef enum { - EMBER_ZCL_COMMAND_IDENTIFICATION_START = 0x01, - EMBER_ZCL_COMMAND_IDENTIFICATION_STOP = 0x02, - EMBER_ZCL_COMMAND_IDENTIFICATION_PAUSE = 0x03, - EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERFREEZING = 0x04, - EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERFREEZING = 0x05, - EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERCOOLING = 0x06, - EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERCOOLING = 0x07, - EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_GAS = 0x08, - EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_GAS = 0x09, - EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_ENERGY_CONTROL = 0x0A, - EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_ENERGY_CONTROL = 0x0B, +typedef enum +{ + EMBER_ZCL_COMMAND_IDENTIFICATION_START = 0x01, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP = 0x02, + EMBER_ZCL_COMMAND_IDENTIFICATION_PAUSE = 0x03, + EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERFREEZING = 0x04, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERFREEZING = 0x05, + EMBER_ZCL_COMMAND_IDENTIFICATION_START_SUPERCOOLING = 0x06, + EMBER_ZCL_COMMAND_IDENTIFICATION_STOP_SUPERCOOLING = 0x07, + EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_GAS = 0x08, + EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_GAS = 0x09, + EMBER_ZCL_COMMAND_IDENTIFICATION_ENABLE_ENERGY_CONTROL = 0x0A, + EMBER_ZCL_COMMAND_IDENTIFICATION_DISABLE_ENERGY_CONTROL = 0x0B, } EmberAfCommandIdentification; -typedef enum { - EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_NO_ACTION = 0x00, - EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_FORM_NETWORK = 0x01, - EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_REJOIN_NETWORK = 0x02, - EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_START_FROM_SCRATCH = 0x03, +typedef enum +{ + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_NO_ACTION = 0x00, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_FORM_NETWORK = 0x01, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_REJOIN_NETWORK = 0x02, + EMBER_ZCL_COMMISSIONING_STARTUP_CONTROL_START_FROM_SCRATCH = 0x03, } EmberAfCommissioningStartupControl; -typedef enum { - EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING = 0x00, - EMBER_ZCL_COMMODITY_TYPE_GAS_METERING = 0x01, - EMBER_ZCL_COMMODITY_TYPE_WATER_METERING = 0x02, - EMBER_ZCL_COMMODITY_TYPE_THERMAL_METERING = 0x03, - EMBER_ZCL_COMMODITY_TYPE_PRESSURE_METERING = 0x04, - EMBER_ZCL_COMMODITY_TYPE_HEAT_METERING = 0x05, - EMBER_ZCL_COMMODITY_TYPE_COOLING_METERING = 0x06, - EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, - EMBER_ZCL_COMMODITY_TYPE_PV_GENERATION_METERING = 0x08, - EMBER_ZCL_COMMODITY_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, - EMBER_ZCL_COMMODITY_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, - EMBER_ZCL_COMMODITY_TYPE_MICRO_GENERATION_METERING = 0x0B, - EMBER_ZCL_COMMODITY_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, - EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, - EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, - EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, +typedef enum +{ + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING = 0x00, + EMBER_ZCL_COMMODITY_TYPE_GAS_METERING = 0x01, + EMBER_ZCL_COMMODITY_TYPE_WATER_METERING = 0x02, + EMBER_ZCL_COMMODITY_TYPE_THERMAL_METERING = 0x03, + EMBER_ZCL_COMMODITY_TYPE_PRESSURE_METERING = 0x04, + EMBER_ZCL_COMMODITY_TYPE_HEAT_METERING = 0x05, + EMBER_ZCL_COMMODITY_TYPE_COOLING_METERING = 0x06, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, + EMBER_ZCL_COMMODITY_TYPE_PV_GENERATION_METERING = 0x08, + EMBER_ZCL_COMMODITY_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, + EMBER_ZCL_COMMODITY_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, + EMBER_ZCL_COMMODITY_TYPE_MICRO_GENERATION_METERING = 0x0B, + EMBER_ZCL_COMMODITY_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, + EMBER_ZCL_COMMODITY_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, } EmberAfCommodityType; -typedef enum { - EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_ACCEPTED = 0x01, - EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_REJECTED = 0x02, +typedef enum +{ + EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_ACCEPTED = 0x01, + EMBER_ZCL_CPP_EVENT_RESPONSE_CPP_AUTH_REJECTED = 0x02, } EmberAfCppEventResponseCppAuth; -typedef enum { - EMBER_ZCL_CPP_PRICE_TIER_CPP1 = 0x00, - EMBER_ZCL_CPP_PRICE_TIER_CPP2 = 0x01, +typedef enum +{ + EMBER_ZCL_CPP_PRICE_TIER_CPP1 = 0x00, + EMBER_ZCL_CPP_PRICE_TIER_CPP2 = 0x01, } EmberAfCppPriceTier; -typedef enum { - EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_INCREMENTAL = 0x00, - EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_ABSOLUTE = 0x01, +typedef enum +{ + EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_INCREMENTAL = 0x00, + EMBER_ZCL_CREDIT_ADJUSTMENT_TYPE_CREDIT_ABSOLUTE = 0x01, } EmberAfCreditAdjustmentType; -typedef enum { - EMBER_ZCL_CREDIT_PAYMENT_STATUS_PENDING = 0x00, - EMBER_ZCL_CREDIT_PAYMENT_STATUS_RECEIVED_PAID = 0x01, - EMBER_ZCL_CREDIT_PAYMENT_STATUS_OVERDUE = 0x02, - EMBER_ZCL_CREDIT_PAYMENT_STATUS_2_PAYMENTS_OVERDUE = 0x03, - EMBER_ZCL_CREDIT_PAYMENT_STATUS_3_PAYMENTS_OVERDUE = 0x04, +typedef enum +{ + EMBER_ZCL_CREDIT_PAYMENT_STATUS_PENDING = 0x00, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_RECEIVED_PAID = 0x01, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_OVERDUE = 0x02, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_2_PAYMENTS_OVERDUE = 0x03, + EMBER_ZCL_CREDIT_PAYMENT_STATUS_3_PAYMENTS_OVERDUE = 0x04, } EmberAfCreditPaymentStatus; -typedef enum { - EMBER_ZCL_DATA_QUALITY_ID_ALL_DATA_CERTIFIED = 0x0000, - EMBER_ZCL_DATA_QUALITY_ID_ONLY_INSTANTANEOUS_POWER_NOT_CERTIFIED = 0x0001, - EMBER_ZCL_DATA_QUALITY_ID_ONLY_CUMULATED_CONSUMPTION_NOT_CERTIFIED = 0x0002, - EMBER_ZCL_DATA_QUALITY_ID_NOT_CERTIFIED_DATA = 0x0003, +typedef enum +{ + EMBER_ZCL_DATA_QUALITY_ID_ALL_DATA_CERTIFIED = 0x0000, + EMBER_ZCL_DATA_QUALITY_ID_ONLY_INSTANTANEOUS_POWER_NOT_CERTIFIED = 0x0001, + EMBER_ZCL_DATA_QUALITY_ID_ONLY_CUMULATED_CONSUMPTION_NOT_CERTIFIED = 0x0002, + EMBER_ZCL_DATA_QUALITY_ID_NOT_CERTIFIED_DATA = 0x0003, } EmberAfDataQualityId; -typedef enum { - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_ABSOLUTE = 0x00, - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_INCREMENTAL = 0x01, - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_ABSOLUTE = 0x02, - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_INCREMENTAL = 0x03, - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_ABSOLUTE = 0x04, - EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_INCREMENTAL = 0x05, +typedef enum +{ + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_ABSOLUTE = 0x00, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE1_INCREMENTAL = 0x01, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_ABSOLUTE = 0x02, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE2_INCREMENTAL = 0x03, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_ABSOLUTE = 0x04, + EMBER_ZCL_DEBT_AMOUNT_TYPE_TYPE3_INCREMENTAL = 0x05, } EmberAfDebtAmountType; -typedef enum { - EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_HOUR = 0x00, - EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_DAY = 0x01, - EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_WEEK = 0x02, - EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_MONTH = 0x03, - EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_QUARTER = 0x04, +typedef enum +{ + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_HOUR = 0x00, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_DAY = 0x01, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_WEEK = 0x02, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_MONTH = 0x03, + EMBER_ZCL_DEBT_RECOVERY_FREQUENCY_PER_QUARTER = 0x04, } EmberAfDebtRecoveryFrequency; -typedef enum { - EMBER_ZCL_DEBT_RECOVERY_METHOD_TIME_BASED = 0x00, - EMBER_ZCL_DEBT_RECOVERY_METHOD_PERCENTAGE_BASED = 0x01, - EMBER_ZCL_DEBT_RECOVERY_METHOD_CATCH_UP_BASED = 0x02, +typedef enum +{ + EMBER_ZCL_DEBT_RECOVERY_METHOD_TIME_BASED = 0x00, + EMBER_ZCL_DEBT_RECOVERY_METHOD_PERCENTAGE_BASED = 0x01, + EMBER_ZCL_DEBT_RECOVERY_METHOD_CATCH_UP_BASED = 0x02, } EmberAfDebtRecoveryMethod; -typedef enum { - EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_NOT_ALLOWED = 0x00, - EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_ALLOWED = 0x01, +typedef enum +{ + EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_NOT_ALLOWED = 0x00, + EMBER_ZCL_DEHUMIDIFCATION_LOCKOUT_ALLOWED = 0x01, } EmberAfDehumidifcationLockout; -typedef enum { - EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_NOT_SORTED = 0x00, - EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_TOP_OF_THE_LIST = 0x01, +typedef enum +{ + EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_NOT_SORTED = 0x00, + EMBER_ZCL_DEVICE_INFORMATION_RECORD_SORT_TOP_OF_THE_LIST = 0x01, } EmberAfDeviceInformationRecordSort; -typedef enum { - EMBER_ZCL_DEVICE_STATUS2_STRUCTURE_IRIS_SYMPTOM_CODE = 0x20, +typedef enum +{ + EMBER_ZCL_DEVICE_STATUS2_STRUCTURE_IRIS_SYMPTOM_CODE = 0x20, } EmberAfDeviceStatus2Structure; -typedef enum { - EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_KEYPAD = 0x00, - EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RF = 0x01, - EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_MANUAL = 0x02, - EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RFID = 0x03, - EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_INDETERMINATE = 0xFF, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_KEYPAD = 0x00, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RF = 0x01, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_MANUAL = 0x02, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_RFID = 0x03, + EMBER_ZCL_DOOR_LOCK_EVENT_SOURCE_INDETERMINATE = 0xFF, } EmberAfDoorLockEventSource; -typedef enum { - EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_OPERATION = 0x00, - EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_PROGRAMMING = 0x01, - EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_ALARM = 0x02, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_OPERATION = 0x00, + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_PROGRAMMING = 0x01, + EMBER_ZCL_DOOR_LOCK_EVENT_TYPE_ALARM = 0x02, } EmberAfDoorLockEventType; -typedef enum { - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NORMAL_MODE = 0x00, - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_VACATION_MODE = 0x01, - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PRIVACY_MODE = 0x02, - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NO_RF_LOCK_OR_UNLOCK = 0x03, - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_LOCAL_PROGRAMMING_MODE = 0x04, - EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PASSAGE_MODE = 0x05, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NORMAL_MODE = 0x00, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_VACATION_MODE = 0x01, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PRIVACY_MODE = 0x02, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_NO_RF_LOCK_OR_UNLOCK = 0x03, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_LOCAL_PROGRAMMING_MODE = 0x04, + EMBER_ZCL_DOOR_LOCK_OPERATING_MODE_PASSAGE_MODE = 0x05, } EmberAfDoorLockOperatingMode; -typedef enum { - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK = 0x01, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK = 0x02, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_PIN_OR_ID = 0x03, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_SCHEDULE = 0x04, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_PIN_OR_ID = 0x05, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_SCHEDULE = 0x06, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_ONE_TOUCH_LOCK = 0x07, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_LOCK = 0x08, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_UNLOCK = 0x09, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_AUTO_LOCK = 0x0A, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_LOCK = 0x0B, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_UNLOCK = 0x0C, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_LOCK = 0x0D, - EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_UNLOCK = 0x0E, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK = 0x01, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK = 0x02, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_PIN_OR_ID = 0x03, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_LOCK_INVALID_SCHEDULE = 0x04, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_PIN_OR_ID = 0x05, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_UNLOCK_INVALID_SCHEDULE = 0x06, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_ONE_TOUCH_LOCK = 0x07, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_LOCK = 0x08, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_KEY_UNLOCK = 0x09, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_AUTO_LOCK = 0x0A, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_LOCK = 0x0B, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_SCHEDULE_UNLOCK = 0x0C, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_LOCK = 0x0D, + EMBER_ZCL_DOOR_LOCK_OPERATION_EVENT_CODE_MANUAL_UNLOCK = 0x0E, } EmberAfDoorLockOperationEventCode; -typedef enum { - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_MASTER_CODE_CHANGED = 0x01, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_ADDED = 0x02, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_DELETED = 0x03, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_CHANGED = 0x04, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_ADDED = 0x05, - EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_DELETED = 0x06, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_UNKNOWN_OR_MFG_SPECIFIC = 0x00, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_MASTER_CODE_CHANGED = 0x01, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_ADDED = 0x02, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_DELETED = 0x03, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_PIN_CHANGED = 0x04, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_ADDED = 0x05, + EMBER_ZCL_DOOR_LOCK_PROGRAMMING_EVENT_CODE_ID_DELETED = 0x06, } EmberAfDoorLockProgrammingEventCode; -typedef enum { - EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_NETWORK_SECURITY = 0x00, - EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_APS_SECURITY = 0x01, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_NETWORK_SECURITY = 0x00, + EMBER_ZCL_DOOR_LOCK_SECURITY_LEVEL_APS_SECURITY = 0x01, } EmberAfDoorLockSecurityLevel; -typedef enum { - EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_SUCCESS = 0x00, - EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_GENERAL_FAILURE = 0x01, - EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_MEMORY_FULL = 0x02, - EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_DUPLICATE_CODE_ERROR = 0x03, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_SUCCESS = 0x00, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_GENERAL_FAILURE = 0x01, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_MEMORY_FULL = 0x02, + EMBER_ZCL_DOOR_LOCK_SET_PIN_OR_ID_STATUS_DUPLICATE_CODE_ERROR = 0x03, } EmberAfDoorLockSetPinOrIdStatus; -typedef enum { - EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_SILENT = 0x00, - EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_LOW = 0x01, - EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_HIGH = 0x02, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_SILENT = 0x00, + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_LOW = 0x01, + EMBER_ZCL_DOOR_LOCK_SOUND_VOLUME_HIGH = 0x02, } EmberAfDoorLockSoundVolume; -typedef enum { - EMBER_ZCL_DOOR_LOCK_STATE_NOT_FULLY_LOCKED = 0x00, - EMBER_ZCL_DOOR_LOCK_STATE_LOCKED = 0x01, - EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED = 0x02, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_STATE_NOT_FULLY_LOCKED = 0x00, + EMBER_ZCL_DOOR_LOCK_STATE_LOCKED = 0x01, + EMBER_ZCL_DOOR_LOCK_STATE_UNLOCKED = 0x02, } EmberAfDoorLockState; -typedef enum { - EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_BOLT = 0x00, - EMBER_ZCL_DOOR_LOCK_TYPE_MAGNETIC = 0x01, - EMBER_ZCL_DOOR_LOCK_TYPE_MORTISE = 0x02, - EMBER_ZCL_DOOR_LOCK_TYPE_RIM = 0x03, - EMBER_ZCL_DOOR_LOCK_TYPE_LATCH_BOLT = 0x04, - EMBER_ZCL_DOOR_LOCK_TYPE_CYLINDRICAL = 0x05, - EMBER_ZCL_DOOR_LOCK_TYPE_TUBULAR = 0x06, - EMBER_ZCL_DOOR_LOCK_TYPE_INTERCONNECTED = 0x07, - EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_LATCH = 0x08, - EMBER_ZCL_DOOR_LOCK_TYPE_OTHER = 0x09, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_BOLT = 0x00, + EMBER_ZCL_DOOR_LOCK_TYPE_MAGNETIC = 0x01, + EMBER_ZCL_DOOR_LOCK_TYPE_MORTISE = 0x02, + EMBER_ZCL_DOOR_LOCK_TYPE_RIM = 0x03, + EMBER_ZCL_DOOR_LOCK_TYPE_LATCH_BOLT = 0x04, + EMBER_ZCL_DOOR_LOCK_TYPE_CYLINDRICAL = 0x05, + EMBER_ZCL_DOOR_LOCK_TYPE_TUBULAR = 0x06, + EMBER_ZCL_DOOR_LOCK_TYPE_INTERCONNECTED = 0x07, + EMBER_ZCL_DOOR_LOCK_TYPE_DEAD_LATCH = 0x08, + EMBER_ZCL_DOOR_LOCK_TYPE_OTHER = 0x09, } EmberAfDoorLockType; -typedef enum { - EMBER_ZCL_DOOR_LOCK_USER_STATUS_AVAILABLE = 0x00, - EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_ENABLED = 0x01, - EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_DISABLED = 0x03, - EMBER_ZCL_DOOR_LOCK_USER_STATUS_NOT_SUPPORTED = 0xFF, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_USER_STATUS_AVAILABLE = 0x00, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_ENABLED = 0x01, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_OCCUPIED_DISABLED = 0x03, + EMBER_ZCL_DOOR_LOCK_USER_STATUS_NOT_SUPPORTED = 0xFF, } EmberAfDoorLockUserStatus; -typedef enum { - EMBER_ZCL_DOOR_LOCK_USER_TYPE_UNRESTRICTED = 0x00, - EMBER_ZCL_DOOR_LOCK_USER_TYPE_ONE_TIME_USER = 0x01, - EMBER_ZCL_DOOR_LOCK_USER_TYPE_USER_WITH_SCHEDULE = 0x02, - EMBER_ZCL_DOOR_LOCK_USER_TYPE_MASTER_USER = 0x03, - EMBER_ZCL_DOOR_LOCK_USER_TYPE_NOT_SUPPORTED = 0xFF, +typedef enum +{ + EMBER_ZCL_DOOR_LOCK_USER_TYPE_UNRESTRICTED = 0x00, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_ONE_TIME_USER = 0x01, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_USER_WITH_SCHEDULE = 0x02, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_MASTER_USER = 0x03, + EMBER_ZCL_DOOR_LOCK_USER_TYPE_NOT_SUPPORTED = 0xFF, } EmberAfDoorLockUserType; -typedef enum { - EMBER_ZCL_DOOR_STATE_OPEN = 0x00, - EMBER_ZCL_DOOR_STATE_CLOSED = 0x01, - EMBER_ZCL_DOOR_STATE_ERROR_JAMMED = 0x02, - EMBER_ZCL_DOOR_STATE_ERROR_FORCED_OPEN = 0x03, - EMBER_ZCL_DOOR_STATE_ERROR_UNSPECIFIED = 0x04, +typedef enum +{ + EMBER_ZCL_DOOR_STATE_OPEN = 0x00, + EMBER_ZCL_DOOR_STATE_CLOSED = 0x01, + EMBER_ZCL_DOOR_STATE_ERROR_JAMMED = 0x02, + EMBER_ZCL_DOOR_STATE_ERROR_FORCED_OPEN = 0x03, + EMBER_ZCL_DOOR_STATE_ERROR_UNSPECIFIED = 0x04, } EmberAfDoorState; -typedef enum { - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L1 = 0x10, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L1 = 0x11, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L2 = 0x12, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L2 = 0x13, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L3 = 0x14, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L3 = 0x15, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L1 = 0x16, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L2 = 0x17, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L3 = 0x18, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L1 = 0x19, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L1 = 0x1A, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L2 = 0x1B, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L2 = 0x1C, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L3 = 0x1D, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L3 = 0x1E, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_GROUND_FAULT = 0x1F, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_ELECTRIC_TAMPER_DETECT = 0x20, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_INCORRECT_POLARITY = 0x21, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_CURRENT_NO_VOLTAGE = 0x22, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_UNDER_VOLTAGE = 0x23, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_VOLTAGE = 0x24, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_NORMAL_VOLTAGE = 0x25, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_BELOW_THRESHOLD = 0x26, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_ABOVE_THRESHOLD = 0x27, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_REMOVED = 0x28, - EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_CLOSED = 0x29, +typedef enum +{ + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L1 = 0x10, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L1 = 0x11, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L2 = 0x12, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L2 = 0x13, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_LOW_VOLTAGE_L3 = 0x14, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_HIGH_VOLTAGE_L3 = 0x15, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L1 = 0x16, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L2 = 0x17, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_CURRENT_L3 = 0x18, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L1 = 0x19, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L1 = 0x1A, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L2 = 0x1B, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L2 = 0x1C, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_LOW_L3 = 0x1D, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_FREQUENCY_TOO_HIGH_L3 = 0x1E, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_GROUND_FAULT = 0x1F, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_ELECTRIC_TAMPER_DETECT = 0x20, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_INCORRECT_POLARITY = 0x21, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_CURRENT_NO_VOLTAGE = 0x22, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_UNDER_VOLTAGE = 0x23, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_OVER_VOLTAGE = 0x24, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_NORMAL_VOLTAGE = 0x25, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_BELOW_THRESHOLD = 0x26, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_P_F_ABOVE_THRESHOLD = 0x27, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_REMOVED = 0x28, + EMBER_ZCL_ELECTRICITY_ALARM_GROUPS_TERMINAL_COVER_CLOSED = 0x29, } EmberAfElectricityAlarmGroups; -typedef enum { - EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, - EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, - EMBER_ZCL_ENHANCED_COLOR_MODE_COLOR_TEMPERATURE = 0x02, - EMBER_ZCL_ENHANCED_COLOR_MODE_ENHANCED_CURRENT_HUE_AND_CURRENT_SATURATION = 0x03, +typedef enum +{ + EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION = 0x00, + EMBER_ZCL_ENHANCED_COLOR_MODE_CURRENT_X_AND_CURRENT_Y = 0x01, + EMBER_ZCL_ENHANCED_COLOR_MODE_COLOR_TEMPERATURE = 0x02, + EMBER_ZCL_ENHANCED_COLOR_MODE_ENHANCED_CURRENT_HUE_AND_CURRENT_SATURATION = 0x03, } EmberAfEnhancedColorMode; -typedef enum { - EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LIST = 0x00, - EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_EVENT_GROUP = 0x01, - EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LOG_TYPE = 0x02, - EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_CONFIGURATION_MATCH = 0x03, +typedef enum +{ + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LIST = 0x00, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_EVENT_GROUP = 0x01, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_LOG_TYPE = 0x02, + EMBER_ZCL_EVENT_CONFIGURATION_CONTROL_APPLY_BY_CONFIGURATION_MATCH = 0x03, } EmberAfEventConfigurationControl; -typedef enum { - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_DO_NOT_LOG = 0x00, - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_TAMPER = 0x01, - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_FAULT = 0x02, - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_GENERAL_EVENT = 0x03, - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_SECURITY_EVENT = 0x04, - EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_NETWORK_EVENT = 0x05, +typedef enum +{ + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_DO_NOT_LOG = 0x00, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_TAMPER = 0x01, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_FAULT = 0x02, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_GENERAL_EVENT = 0x03, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_SECURITY_EVENT = 0x04, + EMBER_ZCL_EVENT_CONFIGURATION_LOG_ACTION_LOG_AS_NETWORK_EVENT = 0x05, } EmberAfEventConfigurationLogAction; -typedef enum { - EMBER_ZCL_EVENT_CONTROL_RETRIEVE_MINIMAL_INFORMATION = 0x00, - EMBER_ZCL_EVENT_CONTROL_RETRIEVE_FULL_INFORMATION = 0x10, +typedef enum +{ + EMBER_ZCL_EVENT_CONTROL_RETRIEVE_MINIMAL_INFORMATION = 0x00, + EMBER_ZCL_EVENT_CONTROL_RETRIEVE_FULL_INFORMATION = 0x10, } EmberAfEventControl; -typedef enum { - EMBER_ZCL_EVENT_ID_METER_COVER_REMOVED = 0x00, - EMBER_ZCL_EVENT_ID_METER_COVER_CLOSED = 0x01, - EMBER_ZCL_EVENT_ID_STRONG_MAGNETIC_FIELD = 0x02, - EMBER_ZCL_EVENT_ID_NO_STRONG_MAGNETIC_FIELD = 0x03, - EMBER_ZCL_EVENT_ID_BATTERY_FAILURE = 0x04, - EMBER_ZCL_EVENT_ID_LOW_BATTERY = 0x05, - EMBER_ZCL_EVENT_ID_PROGRAM_MEMORY_ERROR = 0x06, - EMBER_ZCL_EVENT_ID_RAM_ERROR = 0x07, - EMBER_ZCL_EVENT_ID_NV_MEMORY_ERROR = 0x08, - EMBER_ZCL_EVENT_ID_MEASUREMENT_SYSTEM_ERROR = 0x09, - EMBER_ZCL_EVENT_ID_WATCHDOG_ERROR = 0x0A, - EMBER_ZCL_EVENT_ID_SUPPLY_DISCONNECT_FAILURE = 0x0B, - EMBER_ZCL_EVENT_ID_SUPPLY_CONNECT_FAILURE = 0x0C, - EMBER_ZCL_EVENT_ID_MEASURMENT_SOFTWARE_CHANGED = 0x0D, - EMBER_ZCL_EVENT_ID_DST_ENABLED = 0x0E, - EMBER_ZCL_EVENT_ID_DST_DISABLED = 0x0F, - EMBER_ZCL_EVENT_ID_CLOCK_ADJ_BACKWARD = 0x10, - EMBER_ZCL_EVENT_ID_CLOCK_ADJ_FORWARD = 0x11, - EMBER_ZCL_EVENT_ID_CLOCK_INVALID = 0x12, - EMBER_ZCL_EVENT_ID_COMMS_ERROR_HAN = 0x13, - EMBER_ZCL_EVENT_ID_COMMS_OK_HAN = 0x14, - EMBER_ZCL_EVENT_ID_FRAUD_ATTEMPT = 0x15, - EMBER_ZCL_EVENT_ID_POWER_LOSS = 0x16, - EMBER_ZCL_EVENT_ID_INCORRECT_PROTOCOL = 0x17, - EMBER_ZCL_EVENT_ID_UNUSUAL_HAN_TRAFFIC = 0x18, - EMBER_ZCL_EVENT_ID_UNEXPECTED_CLOCK_CHANGE = 0x19, - EMBER_ZCL_EVENT_ID_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x1A, - EMBER_ZCL_EVENT_ID_ERROR_REG_CLEAR = 0x1B, - EMBER_ZCL_EVENT_ID_ALARM_REG_CLEAR = 0x1C, - EMBER_ZCL_EVENT_ID_UNEXPECTED_HW_RESET = 0x1D, - EMBER_ZCL_EVENT_ID_UNEXPECTED_PROGRAM_EXECUTION = 0x1E, - EMBER_ZCL_EVENT_ID_EVENT_LOG_CLEARED = 0x1F, - EMBER_ZCL_EVENT_ID_MANUAL_DISCONNECT = 0x20, - EMBER_ZCL_EVENT_ID_MANUAL_CONNECT = 0x21, - EMBER_ZCL_EVENT_ID_REMOTE_DISCONNECTION = 0x22, - EMBER_ZCL_EVENT_ID_LOCAL_DISCONNECTION = 0x23, - EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_EXCEEDED = 0x24, - EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_OK = 0x25, - EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_CHANGED = 0x26, - EMBER_ZCL_EVENT_ID_MAXIMUM_DEMAND_EXCEEDED = 0x27, - EMBER_ZCL_EVENT_ID_PROFILE_CLEARED = 0x28, - EMBER_ZCL_EVENT_ID_FIRMWARE_READY_FOR_ACTIVATION = 0x29, - EMBER_ZCL_EVENT_ID_FIRMWARE_ACTIVATED = 0x2A, - EMBER_ZCL_EVENT_ID_PATCH_FAILURE = 0x2B, - EMBER_ZCL_EVENT_ID_TOU_TARIFF_ACTIVATION = 0x2C, - EMBER_ZCL_EVENT_ID_8X8_TARIFFACTIVATED = 0x2D, - EMBER_ZCL_EVENT_ID_SINGLE_TARIFF_RATE_ACTIVATED = 0x2E, - EMBER_ZCL_EVENT_ID_ASYNCHRONOUS_BILLING_OCCURRED = 0x2F, - EMBER_ZCL_EVENT_ID_SYNCHRONOUS_BILLING_OCCURRED = 0x30, - EMBER_ZCL_EVENT_ID_INCORRECT_POLARITY = 0x80, - EMBER_ZCL_EVENT_ID_CURRENT_NO_VOLTAGE = 0x81, - EMBER_ZCL_EVENT_ID_UNDER_VOLTAGE = 0x82, - EMBER_ZCL_EVENT_ID_OVER_VOLTAGE = 0x83, - EMBER_ZCL_EVENT_ID_NORMAL_VOLTAGE = 0x84, - EMBER_ZCL_EVENT_ID_PF_BELOW_THRESHOLD = 0x85, - EMBER_ZCL_EVENT_ID_PF_ABOVE_THRESHOLD = 0x86, - EMBER_ZCL_EVENT_ID_TERMINAL_COVER_REMOVED = 0x87, - EMBER_ZCL_EVENT_ID_TERMINAL_COVER_CLOSED = 0x88, - EMBER_ZCL_EVENT_ID_REVERSE_FLOW = 0xA0, - EMBER_ZCL_EVENT_ID_TILT_TAMPER = 0xA1, - EMBER_ZCL_EVENT_ID_BATTERY_COVER_REMOVED = 0xA2, - EMBER_ZCL_EVENT_ID_BATTERY_COVER_CLOSED = 0xA3, - EMBER_ZCL_EVENT_ID_EXCESS_FLOW = 0xA4, - EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_IN_USE = 0xC0, - EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_EXHAUSTED = 0xC1, - EMBER_ZCL_EVENT_ID_ZERO_CREDIT_EC_NOT_SELECTED = 0xC2, - EMBER_ZCL_EVENT_ID_SUPPLY_ON = 0xC3, - EMBER_ZCL_EVENT_ID_SUPPLY_OFF_AARMED = 0xC4, - EMBER_ZCL_EVENT_ID_SUPPLY_OFF = 0xC5, - EMBER_ZCL_EVENT_ID_DISCOUNT_APPLIED = 0xC6, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_A = 0xE0, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_B = 0xE1, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_C = 0xE2, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_D = 0xE3, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_E = 0xE4, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_F = 0xE5, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_G = 0xE6, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_H = 0xE7, - EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_I = 0xE8, +typedef enum +{ + EMBER_ZCL_EVENT_ID_METER_COVER_REMOVED = 0x00, + EMBER_ZCL_EVENT_ID_METER_COVER_CLOSED = 0x01, + EMBER_ZCL_EVENT_ID_STRONG_MAGNETIC_FIELD = 0x02, + EMBER_ZCL_EVENT_ID_NO_STRONG_MAGNETIC_FIELD = 0x03, + EMBER_ZCL_EVENT_ID_BATTERY_FAILURE = 0x04, + EMBER_ZCL_EVENT_ID_LOW_BATTERY = 0x05, + EMBER_ZCL_EVENT_ID_PROGRAM_MEMORY_ERROR = 0x06, + EMBER_ZCL_EVENT_ID_RAM_ERROR = 0x07, + EMBER_ZCL_EVENT_ID_NV_MEMORY_ERROR = 0x08, + EMBER_ZCL_EVENT_ID_MEASUREMENT_SYSTEM_ERROR = 0x09, + EMBER_ZCL_EVENT_ID_WATCHDOG_ERROR = 0x0A, + EMBER_ZCL_EVENT_ID_SUPPLY_DISCONNECT_FAILURE = 0x0B, + EMBER_ZCL_EVENT_ID_SUPPLY_CONNECT_FAILURE = 0x0C, + EMBER_ZCL_EVENT_ID_MEASURMENT_SOFTWARE_CHANGED = 0x0D, + EMBER_ZCL_EVENT_ID_DST_ENABLED = 0x0E, + EMBER_ZCL_EVENT_ID_DST_DISABLED = 0x0F, + EMBER_ZCL_EVENT_ID_CLOCK_ADJ_BACKWARD = 0x10, + EMBER_ZCL_EVENT_ID_CLOCK_ADJ_FORWARD = 0x11, + EMBER_ZCL_EVENT_ID_CLOCK_INVALID = 0x12, + EMBER_ZCL_EVENT_ID_COMMS_ERROR_HAN = 0x13, + EMBER_ZCL_EVENT_ID_COMMS_OK_HAN = 0x14, + EMBER_ZCL_EVENT_ID_FRAUD_ATTEMPT = 0x15, + EMBER_ZCL_EVENT_ID_POWER_LOSS = 0x16, + EMBER_ZCL_EVENT_ID_INCORRECT_PROTOCOL = 0x17, + EMBER_ZCL_EVENT_ID_UNUSUAL_HAN_TRAFFIC = 0x18, + EMBER_ZCL_EVENT_ID_UNEXPECTED_CLOCK_CHANGE = 0x19, + EMBER_ZCL_EVENT_ID_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x1A, + EMBER_ZCL_EVENT_ID_ERROR_REG_CLEAR = 0x1B, + EMBER_ZCL_EVENT_ID_ALARM_REG_CLEAR = 0x1C, + EMBER_ZCL_EVENT_ID_UNEXPECTED_HW_RESET = 0x1D, + EMBER_ZCL_EVENT_ID_UNEXPECTED_PROGRAM_EXECUTION = 0x1E, + EMBER_ZCL_EVENT_ID_EVENT_LOG_CLEARED = 0x1F, + EMBER_ZCL_EVENT_ID_MANUAL_DISCONNECT = 0x20, + EMBER_ZCL_EVENT_ID_MANUAL_CONNECT = 0x21, + EMBER_ZCL_EVENT_ID_REMOTE_DISCONNECTION = 0x22, + EMBER_ZCL_EVENT_ID_LOCAL_DISCONNECTION = 0x23, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_EXCEEDED = 0x24, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_OK = 0x25, + EMBER_ZCL_EVENT_ID_LIMIT_THRESHOLD_CHANGED = 0x26, + EMBER_ZCL_EVENT_ID_MAXIMUM_DEMAND_EXCEEDED = 0x27, + EMBER_ZCL_EVENT_ID_PROFILE_CLEARED = 0x28, + EMBER_ZCL_EVENT_ID_FIRMWARE_READY_FOR_ACTIVATION = 0x29, + EMBER_ZCL_EVENT_ID_FIRMWARE_ACTIVATED = 0x2A, + EMBER_ZCL_EVENT_ID_PATCH_FAILURE = 0x2B, + EMBER_ZCL_EVENT_ID_TOU_TARIFF_ACTIVATION = 0x2C, + EMBER_ZCL_EVENT_ID_8X8_TARIFFACTIVATED = 0x2D, + EMBER_ZCL_EVENT_ID_SINGLE_TARIFF_RATE_ACTIVATED = 0x2E, + EMBER_ZCL_EVENT_ID_ASYNCHRONOUS_BILLING_OCCURRED = 0x2F, + EMBER_ZCL_EVENT_ID_SYNCHRONOUS_BILLING_OCCURRED = 0x30, + EMBER_ZCL_EVENT_ID_INCORRECT_POLARITY = 0x80, + EMBER_ZCL_EVENT_ID_CURRENT_NO_VOLTAGE = 0x81, + EMBER_ZCL_EVENT_ID_UNDER_VOLTAGE = 0x82, + EMBER_ZCL_EVENT_ID_OVER_VOLTAGE = 0x83, + EMBER_ZCL_EVENT_ID_NORMAL_VOLTAGE = 0x84, + EMBER_ZCL_EVENT_ID_PF_BELOW_THRESHOLD = 0x85, + EMBER_ZCL_EVENT_ID_PF_ABOVE_THRESHOLD = 0x86, + EMBER_ZCL_EVENT_ID_TERMINAL_COVER_REMOVED = 0x87, + EMBER_ZCL_EVENT_ID_TERMINAL_COVER_CLOSED = 0x88, + EMBER_ZCL_EVENT_ID_REVERSE_FLOW = 0xA0, + EMBER_ZCL_EVENT_ID_TILT_TAMPER = 0xA1, + EMBER_ZCL_EVENT_ID_BATTERY_COVER_REMOVED = 0xA2, + EMBER_ZCL_EVENT_ID_BATTERY_COVER_CLOSED = 0xA3, + EMBER_ZCL_EVENT_ID_EXCESS_FLOW = 0xA4, + EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_IN_USE = 0xC0, + EMBER_ZCL_EVENT_ID_EMERGENCY_CREDIT_EXHAUSTED = 0xC1, + EMBER_ZCL_EVENT_ID_ZERO_CREDIT_EC_NOT_SELECTED = 0xC2, + EMBER_ZCL_EVENT_ID_SUPPLY_ON = 0xC3, + EMBER_ZCL_EVENT_ID_SUPPLY_OFF_AARMED = 0xC4, + EMBER_ZCL_EVENT_ID_SUPPLY_OFF = 0xC5, + EMBER_ZCL_EVENT_ID_DISCOUNT_APPLIED = 0xC6, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_A = 0xE0, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_B = 0xE1, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_C = 0xE2, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_D = 0xE3, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_E = 0xE4, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_F = 0xE5, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_G = 0xE6, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_H = 0xE7, + EMBER_ZCL_EVENT_ID_MANUFACTURER_SPECIFIC_I = 0xE8, } EmberAfEventId; -typedef enum { - EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_CYCLE = 0x01, - EMBER_ZCL_EVENT_IDENTIFICATION_TEMPERATURE_REACHED = 0x04, - EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_COOKING = 0x05, - EMBER_ZCL_EVENT_IDENTIFICATION_SWITCHING_OFF = 0x06, - EMBER_ZCL_EVENT_IDENTIFICATION_WRONG_DATA = 0x07, +typedef enum +{ + EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_CYCLE = 0x01, + EMBER_ZCL_EVENT_IDENTIFICATION_TEMPERATURE_REACHED = 0x04, + EMBER_ZCL_EVENT_IDENTIFICATION_END_OF_COOKING = 0x05, + EMBER_ZCL_EVENT_IDENTIFICATION_SWITCHING_OFF = 0x06, + EMBER_ZCL_EVENT_IDENTIFICATION_WRONG_DATA = 0x07, } EmberAfEventIdentification; -typedef enum { - EMBER_ZCL_EVENT_LOG_ID_ALL_LOGS = 0x00, - EMBER_ZCL_EVENT_LOG_ID_TAMPER_LOG = 0x01, - EMBER_ZCL_EVENT_LOG_ID_FAULT_LOG = 0x02, - EMBER_ZCL_EVENT_LOG_ID_GENERAL_EVENT_LOG = 0x03, - EMBER_ZCL_EVENT_LOG_ID_SECURITY_EVENT_LOG = 0x04, - EMBER_ZCL_EVENT_LOG_ID_NETWORK_EVENT_LOG = 0x05, - EMBER_ZCL_EVENT_LOG_ID_GBCS_GENERAL_EVENT_LOG = 0x06, - EMBER_ZCL_EVENT_LOG_ID_GBCS_SECURITY_EVENT_LOG = 0x07, +typedef enum +{ + EMBER_ZCL_EVENT_LOG_ID_ALL_LOGS = 0x00, + EMBER_ZCL_EVENT_LOG_ID_TAMPER_LOG = 0x01, + EMBER_ZCL_EVENT_LOG_ID_FAULT_LOG = 0x02, + EMBER_ZCL_EVENT_LOG_ID_GENERAL_EVENT_LOG = 0x03, + EMBER_ZCL_EVENT_LOG_ID_SECURITY_EVENT_LOG = 0x04, + EMBER_ZCL_EVENT_LOG_ID_NETWORK_EVENT_LOG = 0x05, + EMBER_ZCL_EVENT_LOG_ID_GBCS_GENERAL_EVENT_LOG = 0x06, + EMBER_ZCL_EVENT_LOG_ID_GBCS_SECURITY_EVENT_LOG = 0x07, } EmberAfEventLogId; -typedef enum { - EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENTS_DO_NOT_CROSS_FRAME_BOUNDARY = 0x00, - EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENT_CROSSES_FRAME_BOUNDARY = 0x01, +typedef enum +{ + EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENTS_DO_NOT_CROSS_FRAME_BOUNDARY = 0x00, + EMBER_ZCL_EVENT_LOG_PAYLOAD_CONTROL_EVENT_CROSSES_FRAME_BOUNDARY = 0x01, } EmberAfEventLogPayloadControl; -typedef enum { - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASUREMENT_SYSTEM_ERROR = 0x70, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WATCHDOG_ERROR = 0x71, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_DISCONNECT_FAILURE = 0x72, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_CONNECT_FAILURE = 0x73, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASURMENT_SOFTWARE_CHANGED = 0x74, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_ENABLED = 0x75, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_DISABLED = 0x76, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_BACKWARD = 0x77, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_FORWARD = 0x78, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_INVALID = 0x79, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_ERROR_HAN = 0x7A, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_OK_H_AN = 0x7B, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_FRAUD_ATTEMPT = 0x7C, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_POWER_LOSS = 0x7D, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNUSUAL_HAN_TRAFFIC = 0x7E, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_CLOCK_CHANGE = 0x7F, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ERROR_REG_CLEAR = 0x81, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ALARM_REG_CLEAR = 0x82, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_HW_RESET = 0x83, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_PROGRAM_EXECUTION = 0x84, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EVENT_LOG_CLEARED = 0x85, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_EXCEEDED = 0x86, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_OK = 0x87, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_CHANGED = 0x88, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MAXIMUM_DEMAND_EXCEEDED = 0x89, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_PROFILE_CLEARED = 0x8A, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SAMPLING_BUFFERCLEARED = 0x8B, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_BATTERY_WARNING = 0x8C, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WRONG_SIGNATURE = 0x8D, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_NO_SIGNATURE = 0x8E, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_START = 0x90, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_END = 0x91, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_REPORTING_INTERVAL_CHANGED = 0x92, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, - EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, +typedef enum +{ + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASUREMENT_SYSTEM_ERROR = 0x70, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WATCHDOG_ERROR = 0x71, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_DISCONNECT_FAILURE = 0x72, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SUPPLY_CONNECT_FAILURE = 0x73, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MEASURMENT_SOFTWARE_CHANGED = 0x74, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_ENABLED = 0x75, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DST_DISABLED = 0x76, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_BACKWARD = 0x77, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_ADJ_FORWARD = 0x78, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_CLOCK_INVALID = 0x79, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_ERROR_HAN = 0x7A, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMUNICATION_OK_H_AN = 0x7B, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_FRAUD_ATTEMPT = 0x7C, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_POWER_LOSS = 0x7D, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNUSUAL_HAN_TRAFFIC = 0x7E, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_CLOCK_CHANGE = 0x7F, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ERROR_REG_CLEAR = 0x81, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_ALARM_REG_CLEAR = 0x82, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_HW_RESET = 0x83, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNEXPECTED_PROGRAM_EXECUTION = 0x84, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EVENT_LOG_CLEARED = 0x85, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_EXCEEDED = 0x86, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_OK = 0x87, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_LIMIT_THRESHOLD_CHANGED = 0x88, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_MAXIMUM_DEMAND_EXCEEDED = 0x89, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_PROFILE_CLEARED = 0x8A, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_SAMPLING_BUFFERCLEARED = 0x8B, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_BATTERY_WARNING = 0x8C, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_WRONG_SIGNATURE = 0x8D, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_NO_SIGNATURE = 0x8E, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_START = 0x90, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_FAST_POLLING_END = 0x91, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_REPORTING_INTERVAL_CHANGED = 0x92, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, + EMBER_ZCL_EXTENDED_GENERIC_ALARM_GROUPS_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, } EmberAfExtendedGenericAlarmGroups; -typedef enum { - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_REFER_TO_NUMBER_OF_PRICE_TIERS_FIELD = 0x00, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS16 = 0x01, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS17 = 0x02, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS18 = 0x03, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS19 = 0x04, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS20 = 0x05, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS21 = 0x06, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS22 = 0x07, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS23 = 0x08, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS24 = 0x09, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS25 = 0x0A, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS26 = 0x0B, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS27 = 0x0C, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS28 = 0x0D, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS29 = 0x0E, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS30 = 0x0F, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS31 = 0x10, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS32 = 0x11, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS33 = 0x12, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS34 = 0x13, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS35 = 0x14, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS36 = 0x15, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS37 = 0x16, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS38 = 0x17, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS39 = 0x18, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS40 = 0x19, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS41 = 0x1A, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS42 = 0x1B, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS43 = 0x1C, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS44 = 0x1D, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS45 = 0x1E, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS46 = 0x1F, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS47 = 0x20, - EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS48 = 0x21, +typedef enum +{ + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_REFER_TO_NUMBER_OF_PRICE_TIERS_FIELD = 0x00, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS16 = 0x01, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS17 = 0x02, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS18 = 0x03, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS19 = 0x04, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS20 = 0x05, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS21 = 0x06, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS22 = 0x07, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS23 = 0x08, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS24 = 0x09, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS25 = 0x0A, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS26 = 0x0B, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS27 = 0x0C, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS28 = 0x0D, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS29 = 0x0E, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS30 = 0x0F, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS31 = 0x10, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS32 = 0x11, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS33 = 0x12, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS34 = 0x13, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS35 = 0x14, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS36 = 0x15, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS37 = 0x16, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS38 = 0x17, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS39 = 0x18, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS40 = 0x19, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS41 = 0x1A, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS42 = 0x1B, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS43 = 0x1C, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS44 = 0x1D, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS45 = 0x1E, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS46 = 0x1F, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS47 = 0x20, + EMBER_ZCL_EXTENDED_NUMBER_OF_PRICE_TIERS_NUMBER_OF_PRICE_TIERS48 = 0x21, } EmberAfExtendedNumberOfPriceTiers; -typedef enum { - EMBER_ZCL_EXTENDED_PRICE_TIER_REFER_TO_PRICE_TIER_FIELD = 0x00, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER16_PRICE_LABEL = 0x01, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER17_PRICE_LABEL = 0x02, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER18_PRICE_LABEL = 0x03, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER19_PRICE_LABEL = 0x04, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER20_PRICE_LABEL = 0x05, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER21_PRICE_LABEL = 0x06, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER22_PRICE_LABEL = 0x07, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER23_PRICE_LABEL = 0x08, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER24_PRICE_LABEL = 0x09, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER25_PRICE_LABEL = 0x0A, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER26_PRICE_LABEL = 0x0B, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER27_PRICE_LABEL = 0x0C, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER28_PRICE_LABEL = 0x0D, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER29_PRICE_LABEL = 0x0E, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER30_PRICE_LABEL = 0x0F, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER31_PRICE_LABEL = 0x10, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER32_PRICE_LABEL = 0x11, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER33_PRICE_LABEL = 0x12, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER34_PRICE_LABEL = 0x13, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER35_PRICE_LABEL = 0x14, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER36_PRICE_LABEL = 0x15, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER37_PRICE_LABEL = 0x16, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER38_PRICE_LABEL = 0x17, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER39_PRICE_LABEL = 0x18, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER40_PRICE_LABEL = 0x19, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER41_PRICE_LABEL = 0x1A, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER42_PRICE_LABEL = 0x1B, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER43_PRICE_LABEL = 0x1C, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER44_PRICE_LABEL = 0x1D, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER45_PRICE_LABEL = 0x1E, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER46_PRICE_LABEL = 0x1F, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER47_PRICE_LABEL = 0x20, - EMBER_ZCL_EXTENDED_PRICE_TIER_TIER48_PRICE_LABEL = 0x21, +typedef enum +{ + EMBER_ZCL_EXTENDED_PRICE_TIER_REFER_TO_PRICE_TIER_FIELD = 0x00, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER16_PRICE_LABEL = 0x01, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER17_PRICE_LABEL = 0x02, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER18_PRICE_LABEL = 0x03, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER19_PRICE_LABEL = 0x04, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER20_PRICE_LABEL = 0x05, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER21_PRICE_LABEL = 0x06, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER22_PRICE_LABEL = 0x07, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER23_PRICE_LABEL = 0x08, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER24_PRICE_LABEL = 0x09, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER25_PRICE_LABEL = 0x0A, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER26_PRICE_LABEL = 0x0B, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER27_PRICE_LABEL = 0x0C, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER28_PRICE_LABEL = 0x0D, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER29_PRICE_LABEL = 0x0E, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER30_PRICE_LABEL = 0x0F, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER31_PRICE_LABEL = 0x10, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER32_PRICE_LABEL = 0x11, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER33_PRICE_LABEL = 0x12, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER34_PRICE_LABEL = 0x13, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER35_PRICE_LABEL = 0x14, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER36_PRICE_LABEL = 0x15, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER37_PRICE_LABEL = 0x16, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER38_PRICE_LABEL = 0x17, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER39_PRICE_LABEL = 0x18, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER40_PRICE_LABEL = 0x19, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER41_PRICE_LABEL = 0x1A, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER42_PRICE_LABEL = 0x1B, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER43_PRICE_LABEL = 0x1C, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER44_PRICE_LABEL = 0x1D, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER45_PRICE_LABEL = 0x1E, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER46_PRICE_LABEL = 0x1F, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER47_PRICE_LABEL = 0x20, + EMBER_ZCL_EXTENDED_PRICE_TIER_TIER48_PRICE_LABEL = 0x21, } EmberAfExtendedPriceTier; -typedef enum { - EMBER_ZCL_EXTENDED_REGISTER_TIER_REFER_TO_REGISTER_TIER_FIELD = 0x00, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE = 0x10, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE = 0x11, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE = 0x12, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE = 0x13, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE = 0x14, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE = 0x15, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE = 0x16, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE = 0x17, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE = 0x18, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE = 0x19, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE = 0x1A, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE = 0x1B, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE = 0x1C, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE = 0x1D, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE = 0x1E, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE = 0x1F, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE = 0x20, - EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE = 0x21, +typedef enum +{ + EMBER_ZCL_EXTENDED_REGISTER_TIER_REFER_TO_REGISTER_TIER_FIELD = 0x00, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER16_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER17_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER18_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER19_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER20_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER21_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER22_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER23_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER24_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER25_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER26_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER27_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER28_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER29_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER30_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER31_SUMMATION_DELIVERED_ATTRIBUTE = 0x10, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER32_SUMMATION_DELIVERED_ATTRIBUTE = 0x11, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER33_SUMMATION_DELIVERED_ATTRIBUTE = 0x12, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER34_SUMMATION_DELIVERED_ATTRIBUTE = 0x13, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER35_SUMMATION_DELIVERED_ATTRIBUTE = 0x14, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER36_SUMMATION_DELIVERED_ATTRIBUTE = 0x15, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER37_SUMMATION_DELIVERED_ATTRIBUTE = 0x16, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER38_SUMMATION_DELIVERED_ATTRIBUTE = 0x17, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER39_SUMMATION_DELIVERED_ATTRIBUTE = 0x18, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER40_SUMMATION_DELIVERED_ATTRIBUTE = 0x19, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER41_SUMMATION_DELIVERED_ATTRIBUTE = 0x1A, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER42_SUMMATION_DELIVERED_ATTRIBUTE = 0x1B, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER43_SUMMATION_DELIVERED_ATTRIBUTE = 0x1C, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER44_SUMMATION_DELIVERED_ATTRIBUTE = 0x1D, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER45_SUMMATION_DELIVERED_ATTRIBUTE = 0x1E, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER46_SUMMATION_DELIVERED_ATTRIBUTE = 0x1F, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER47_SUMMATION_DELIVERED_ATTRIBUTE = 0x20, + EMBER_ZCL_EXTENDED_REGISTER_TIER_CURRENT_TIER48_SUMMATION_DELIVERED_ATTRIBUTE = 0x21, } EmberAfExtendedRegisterTier; -typedef enum { - EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_SERVER = 0x00, - EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_CLIENT = 0x01, +typedef enum +{ + EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_SERVER = 0x00, + EMBER_ZCL_EZ_MODE_COMMISSIONING_CLUSTER_TYPE_CLIENT = 0x01, } EmberAfEzModeCommissioningClusterType; -typedef enum { - EMBER_ZCL_FAN_MODE_OFF = 0x00, - EMBER_ZCL_FAN_MODE_LOW = 0x01, - EMBER_ZCL_FAN_MODE_MEDIUM = 0x02, - EMBER_ZCL_FAN_MODE_HIGH = 0x03, - EMBER_ZCL_FAN_MODE_ON = 0x04, - EMBER_ZCL_FAN_MODE_AUTO = 0x05, - EMBER_ZCL_FAN_MODE_SMART = 0x06, +typedef enum +{ + EMBER_ZCL_FAN_MODE_OFF = 0x00, + EMBER_ZCL_FAN_MODE_LOW = 0x01, + EMBER_ZCL_FAN_MODE_MEDIUM = 0x02, + EMBER_ZCL_FAN_MODE_HIGH = 0x03, + EMBER_ZCL_FAN_MODE_ON = 0x04, + EMBER_ZCL_FAN_MODE_AUTO = 0x05, + EMBER_ZCL_FAN_MODE_SMART = 0x06, } EmberAfFanMode; -typedef enum { - EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH = 0x00, - EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH = 0x01, - EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH_AUTO = 0x02, - EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH_AUTO = 0x03, - EMBER_ZCL_FAN_MODE_SEQUENCE_ON_AUTO = 0x04, +typedef enum +{ + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH = 0x00, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH = 0x01, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_MED_HIGH_AUTO = 0x02, + EMBER_ZCL_FAN_MODE_SEQUENCE_LOW_HIGH_AUTO = 0x03, + EMBER_ZCL_FAN_MODE_SEQUENCE_ON_AUTO = 0x04, } EmberAfFanModeSequence; -typedef enum { - EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER = 0x60, - EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_REMOVED = 0x61, - EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_CLOSED = 0x62, - EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_EXCESS_FLOW = 0x63, - EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER_ENDED = 0x64, +typedef enum +{ + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER = 0x60, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_REMOVED = 0x61, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_BATTERY_COVER_CLOSED = 0x62, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_EXCESS_FLOW = 0x63, + EMBER_ZCL_GAS_SPECIFIC_ALARM_GROUPS_TILT_TAMPER_ENDED = 0x64, } EmberAfGasSpecificAlarmGroups; -typedef enum { - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE = 0x01, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE = 0x02, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE = 0x03, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE = 0x04, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE = 0x05, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE = 0x06, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE = 0x07, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE = 0x08, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE = 0x09, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE = 0x0A, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE = 0x0B, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE = 0x0C, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE = 0x0D, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE = 0x0E, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE = 0x0F, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE = 0x10, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE = 0x11, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE = 0x12, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE = 0x13, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE = 0x14, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE = 0x15, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE = 0x16, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE = 0x17, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE = 0x18, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE = 0x19, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE = 0x1A, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE = 0x1B, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE = 0x1C, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE = 0x1D, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE = 0x1E, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE = 0x1F, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE = 0x20, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE = 0x21, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE = 0x22, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE = 0x23, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE = 0x24, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE = 0x25, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE = 0x26, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE = 0x27, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE = 0x28, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE = 0x29, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE = 0x2A, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE = 0x2B, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE = 0x2C, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE = 0x2D, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE = 0x2E, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE = 0x2F, - EMBER_ZCL_GENERATION_TIER_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE = 0x30, +typedef enum +{ + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER1_SUMMATION_RECEIVED_ATTRIBUTE = 0x01, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER2_SUMMATION_RECEIVED_ATTRIBUTE = 0x02, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER3_SUMMATION_RECEIVED_ATTRIBUTE = 0x03, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER4_SUMMATION_RECEIVED_ATTRIBUTE = 0x04, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER5_SUMMATION_RECEIVED_ATTRIBUTE = 0x05, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER6_SUMMATION_RECEIVED_ATTRIBUTE = 0x06, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER7_SUMMATION_RECEIVED_ATTRIBUTE = 0x07, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER8_SUMMATION_RECEIVED_ATTRIBUTE = 0x08, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER9_SUMMATION_RECEIVED_ATTRIBUTE = 0x09, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER10_SUMMATION_RECEIVED_ATTRIBUTE = 0x0A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER11_SUMMATION_RECEIVED_ATTRIBUTE = 0x0B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER12_SUMMATION_RECEIVED_ATTRIBUTE = 0x0C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER13_SUMMATION_RECEIVED_ATTRIBUTE = 0x0D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER14_SUMMATION_RECEIVED_ATTRIBUTE = 0x0E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER15_SUMMATION_RECEIVED_ATTRIBUTE = 0x0F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER16_SUMMATION_RECEIVED_ATTRIBUTE = 0x10, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER17_SUMMATION_RECEIVED_ATTRIBUTE = 0x11, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER18_SUMMATION_RECEIVED_ATTRIBUTE = 0x12, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER19_SUMMATION_RECEIVED_ATTRIBUTE = 0x13, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER20_SUMMATION_RECEIVED_ATTRIBUTE = 0x14, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER21_SUMMATION_RECEIVED_ATTRIBUTE = 0x15, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER22_SUMMATION_RECEIVED_ATTRIBUTE = 0x16, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER23_SUMMATION_RECEIVED_ATTRIBUTE = 0x17, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER24_SUMMATION_RECEIVED_ATTRIBUTE = 0x18, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER25_SUMMATION_RECEIVED_ATTRIBUTE = 0x19, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER26_SUMMATION_RECEIVED_ATTRIBUTE = 0x1A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER27_SUMMATION_RECEIVED_ATTRIBUTE = 0x1B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER28_SUMMATION_RECEIVED_ATTRIBUTE = 0x1C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER29_SUMMATION_RECEIVED_ATTRIBUTE = 0x1D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER30_SUMMATION_RECEIVED_ATTRIBUTE = 0x1E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER31_SUMMATION_RECEIVED_ATTRIBUTE = 0x1F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER32_SUMMATION_RECEIVED_ATTRIBUTE = 0x20, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER33_SUMMATION_RECEIVED_ATTRIBUTE = 0x21, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER34_SUMMATION_RECEIVED_ATTRIBUTE = 0x22, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER35_SUMMATION_RECEIVED_ATTRIBUTE = 0x23, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER36_SUMMATION_RECEIVED_ATTRIBUTE = 0x24, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER37_SUMMATION_RECEIVED_ATTRIBUTE = 0x25, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER38_SUMMATION_RECEIVED_ATTRIBUTE = 0x26, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER39_SUMMATION_RECEIVED_ATTRIBUTE = 0x27, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER40_SUMMATION_RECEIVED_ATTRIBUTE = 0x28, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER41_SUMMATION_RECEIVED_ATTRIBUTE = 0x29, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER42_SUMMATION_RECEIVED_ATTRIBUTE = 0x2A, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER43_SUMMATION_RECEIVED_ATTRIBUTE = 0x2B, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER44_SUMMATION_RECEIVED_ATTRIBUTE = 0x2C, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER45_SUMMATION_RECEIVED_ATTRIBUTE = 0x2D, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER46_SUMMATION_RECEIVED_ATTRIBUTE = 0x2E, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER47_SUMMATION_RECEIVED_ATTRIBUTE = 0x2F, + EMBER_ZCL_GENERATION_TIER_CURRENT_TIER48_SUMMATION_RECEIVED_ATTRIBUTE = 0x30, } EmberAfGenerationTier; -typedef enum { - EMBER_ZCL_GENERIC_ALARM_GROUPS_CHECK_METER = 0x00, - EMBER_ZCL_GENERIC_ALARM_GROUPS_LOW_BATTERY = 0x01, - EMBER_ZCL_GENERIC_ALARM_GROUPS_TAMPER_DETECT = 0x02, - EMBER_ZCL_GENERIC_ALARM_GROUPS_LEAK_DETECT = 0x05, - EMBER_ZCL_GENERIC_ALARM_GROUPS_SERVICE_DISCONNECT = 0x06, - EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_REMOVED = 0x08, - EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_CLOSED = 0x09, - EMBER_ZCL_GENERIC_ALARM_GROUPS_STRONG_MAGNETIC_FIELD = 0x0A, - EMBER_ZCL_GENERIC_ALARM_GROUPS_NO_STRONG_MAGNETIC_FIELD = 0x0B, - EMBER_ZCL_GENERIC_ALARM_GROUPS_BATTERY_FAILURE = 0x0C, - EMBER_ZCL_GENERIC_ALARM_GROUPS_PROGRAM_MEMORY_ERROR = 0x0D, - EMBER_ZCL_GENERIC_ALARM_GROUPS_R_A_M_ERROR = 0x0E, - EMBER_ZCL_GENERIC_ALARM_GROUPS_N_V_MEMORY_ERROR = 0x0F, +typedef enum +{ + EMBER_ZCL_GENERIC_ALARM_GROUPS_CHECK_METER = 0x00, + EMBER_ZCL_GENERIC_ALARM_GROUPS_LOW_BATTERY = 0x01, + EMBER_ZCL_GENERIC_ALARM_GROUPS_TAMPER_DETECT = 0x02, + EMBER_ZCL_GENERIC_ALARM_GROUPS_LEAK_DETECT = 0x05, + EMBER_ZCL_GENERIC_ALARM_GROUPS_SERVICE_DISCONNECT = 0x06, + EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_REMOVED = 0x08, + EMBER_ZCL_GENERIC_ALARM_GROUPS_METER_COVER_CLOSED = 0x09, + EMBER_ZCL_GENERIC_ALARM_GROUPS_STRONG_MAGNETIC_FIELD = 0x0A, + EMBER_ZCL_GENERIC_ALARM_GROUPS_NO_STRONG_MAGNETIC_FIELD = 0x0B, + EMBER_ZCL_GENERIC_ALARM_GROUPS_BATTERY_FAILURE = 0x0C, + EMBER_ZCL_GENERIC_ALARM_GROUPS_PROGRAM_MEMORY_ERROR = 0x0D, + EMBER_ZCL_GENERIC_ALARM_GROUPS_R_A_M_ERROR = 0x0E, + EMBER_ZCL_GENERIC_ALARM_GROUPS_N_V_MEMORY_ERROR = 0x0F, } EmberAfGenericAlarmGroups; -typedef enum { - EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_FAILURE = 0x03, - EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_QUALITY = 0x04, +typedef enum +{ + EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_FAILURE = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_ELECTRICITY_POWER_QUALITY = 0x04, } EmberAfGenericAlarmGroupsElectricity; -typedef enum { - EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_LOW_PRESSURE = 0x04, - EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_REVERSE_FLOW = 0x07, +typedef enum +{ + EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_LOW_PRESSURE = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_GAS_REVERSE_FLOW = 0x07, } EmberAfGenericAlarmGroupsGas; -typedef enum { - EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_TEMPERATURE_SENSOR = 0x03, - EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_BURST_DETECT = 0x04, - EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_FLOW_SENSOR = 0x07, +typedef enum +{ + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_TEMPERATURE_SENSOR = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_BURST_DETECT = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_HEAT_COOLING_FLOW_SENSOR = 0x07, } EmberAfGenericAlarmGroupsHeatCooling; -typedef enum { - EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_PIPE_EMPTY = 0x03, - EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_LOW_PRESSURE = 0x04, - EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_REVERSE_FLOW = 0x07, +typedef enum +{ + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_PIPE_EMPTY = 0x03, + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_LOW_PRESSURE = 0x04, + EMBER_ZCL_GENERIC_ALARM_GROUPS_WATER_WATER_REVERSE_FLOW = 0x07, } EmberAfGenericAlarmGroupsWater; -typedef enum { - EMBER_ZCL_GENERIC_DEVICE_CLASS_LIGHTING = 0x00, +typedef enum +{ + EMBER_ZCL_GENERIC_DEVICE_CLASS_LIGHTING = 0x00, } EmberAfGenericDeviceClass; -typedef enum { - EMBER_ZCL_GENERIC_DEVICE_TYPE_INCANDESCENT = 0x00, - EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_HALOGEN = 0x01, - EMBER_ZCL_GENERIC_DEVICE_TYPE_HALOGEN_BULB = 0x02, - EMBER_ZCL_GENERIC_DEVICE_TYPE_CFL = 0x03, - EMBER_ZCL_GENERIC_DEVICE_TYPE_LINEAR_FLOURESCENT = 0x04, - EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_BULB = 0x05, - EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_LED = 0x06, - EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_STRIP = 0x07, - EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_TUBE = 0x08, - EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_INDOOR_FIXTURE = 0x09, - EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_OUTDOOR_FIXTURE = 0x0A, - EMBER_ZCL_GENERIC_DEVICE_TYPE_PENDANT_FIXTURE = 0x0B, - EMBER_ZCL_GENERIC_DEVICE_TYPE_FLOOR_STANDING_FIXTURE = 0x0C, - EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_CONTROLLER = 0xE0, - EMBER_ZCL_GENERIC_DEVICE_TYPE_WALL_SWITCH = 0xE1, - EMBER_ZCL_GENERIC_DEVICE_TYPE_PORTABLE_REMOTE_CONTROLLER = 0xE2, - EMBER_ZCL_GENERIC_DEVICE_TYPE_MOTION_OR_LIGHT_SENSOR = 0xE3, - EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_ACTUATOR = 0xF0, - EMBER_ZCL_GENERIC_DEVICE_TYPE_PLUGIN_UNIT = 0xF1, - EMBER_ZCL_GENERIC_DEVICE_TYPE_RETROFIT_ACTUATOR = 0xF2, - EMBER_ZCL_GENERIC_DEVICE_TYPE_UNSPECIFIED = 0xFF, +typedef enum +{ + EMBER_ZCL_GENERIC_DEVICE_TYPE_INCANDESCENT = 0x00, + EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_HALOGEN = 0x01, + EMBER_ZCL_GENERIC_DEVICE_TYPE_HALOGEN_BULB = 0x02, + EMBER_ZCL_GENERIC_DEVICE_TYPE_CFL = 0x03, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LINEAR_FLOURESCENT = 0x04, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_BULB = 0x05, + EMBER_ZCL_GENERIC_DEVICE_TYPE_SPOTLIGHT_LED = 0x06, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_STRIP = 0x07, + EMBER_ZCL_GENERIC_DEVICE_TYPE_LED_TUBE = 0x08, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_INDOOR_FIXTURE = 0x09, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_OUTDOOR_FIXTURE = 0x0A, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PENDANT_FIXTURE = 0x0B, + EMBER_ZCL_GENERIC_DEVICE_TYPE_FLOOR_STANDING_FIXTURE = 0x0C, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_CONTROLLER = 0xE0, + EMBER_ZCL_GENERIC_DEVICE_TYPE_WALL_SWITCH = 0xE1, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PORTABLE_REMOTE_CONTROLLER = 0xE2, + EMBER_ZCL_GENERIC_DEVICE_TYPE_MOTION_OR_LIGHT_SENSOR = 0xE3, + EMBER_ZCL_GENERIC_DEVICE_TYPE_GENERIC_ACTUATOR = 0xF0, + EMBER_ZCL_GENERIC_DEVICE_TYPE_PLUGIN_UNIT = 0xF1, + EMBER_ZCL_GENERIC_DEVICE_TYPE_RETROFIT_ACTUATOR = 0xF2, + EMBER_ZCL_GENERIC_DEVICE_TYPE_UNSPECIFIED = 0xFF, } EmberAfGenericDeviceType; -typedef enum { - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_BURST_DETECT = 0x30, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_LOW = 0x31, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_HIGH = 0x32, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_REVERSE_FLOW = 0x35, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_AIR_DETECT = 0x36, - EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PIPE_EMPTY = 0x37, +typedef enum +{ + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_BURST_DETECT = 0x30, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_LOW = 0x31, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PRESSURE_TOO_HIGH = 0x32, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_REVERSE_FLOW = 0x35, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_FLOW_SENSOR_AIR_DETECT = 0x36, + EMBER_ZCL_GENERIC_FLOW_PRESSURE_ALARM_GROUPS_PIPE_EMPTY = 0x37, } EmberAfGenericFlowPressureAlarmGroups; -typedef enum { - EMBER_ZCL_GP_DEVICE_ID_GP_SIMPLE_GENERICE_TWO_STATE_SWITCH = 0x00, - EMBER_ZCL_GP_DEVICE_ID_GP_ON_OFF_SWITCH = 0x08, - EMBER_ZCL_GP_DEVICE_ID_GP_LEVEL_CONTROL_SWITCH = 0x10, - EMBER_ZCL_GP_DEVICE_ID_GP_INDOOR_ENVIRONMENT_SNESOR = 0x18, +typedef enum +{ + EMBER_ZCL_GP_DEVICE_ID_GP_SIMPLE_GENERICE_TWO_STATE_SWITCH = 0x00, + EMBER_ZCL_GP_DEVICE_ID_GP_ON_OFF_SWITCH = 0x08, + EMBER_ZCL_GP_DEVICE_ID_GP_LEVEL_CONTROL_SWITCH = 0x10, + EMBER_ZCL_GP_DEVICE_ID_GP_INDOOR_ENVIRONMENT_SNESOR = 0x18, } EmberAfGpDeviceId; -typedef enum { - EMBER_ZCL_GP_GPDF_IDENTIFY = 0x00, - EMBER_ZCL_GP_GPDF_MATCH_ONLY_ON_GPD_ADDRESS = 0x02, - EMBER_ZCL_GP_GPDF_RECALL_SCENE0 = 0x10, - EMBER_ZCL_GP_GPDF_RECALL_SCENE1 = 0x11, - EMBER_ZCL_GP_GPDF_RECALL_SCENE2 = 0x12, - EMBER_ZCL_GP_GPDF_RECALL_SCENE3 = 0x13, - EMBER_ZCL_GP_GPDF_RECALL_SCENE4 = 0x14, - EMBER_ZCL_GP_GPDF_RECALL_SCENE5 = 0x15, - EMBER_ZCL_GP_GPDF_RECALL_SCENE6 = 0x16, - EMBER_ZCL_GP_GPDF_RECALL_SCENE7 = 0x17, - EMBER_ZCL_GP_GPDF_STORE_SCENE0 = 0x18, - EMBER_ZCL_GP_GPDF_STORE_SCENE1 = 0x19, - EMBER_ZCL_GP_GPDF_STORE_SCENE2 = 0x1A, - EMBER_ZCL_GP_GPDF_STORE_SCENE3 = 0x1B, - EMBER_ZCL_GP_GPDF_STORE_SCENE4 = 0x1C, - EMBER_ZCL_GP_GPDF_STORE_SCENE5 = 0x1D, - EMBER_ZCL_GP_GPDF_STORE_SCENE6 = 0x1E, - EMBER_ZCL_GP_GPDF_STORE_SCENE7 = 0x1F, - EMBER_ZCL_GP_GPDF_OFF = 0x20, - EMBER_ZCL_GP_GPDF_ON = 0x21, - EMBER_ZCL_GP_GPDF_TOGGLE = 0x22, - EMBER_ZCL_GP_GPDF_RELEASE = 0x23, - EMBER_ZCL_GP_GPDF_MOVE_UP = 0x30, - EMBER_ZCL_GP_GPDF_MOVE_DOWN = 0x31, - EMBER_ZCL_GP_GPDF_STEP_UP = 0x32, - EMBER_ZCL_GP_GPDF_STEP_DOWN = 0x33, - EMBER_ZCL_GP_GPDF_LEVEL_CONTROL_STOP = 0x34, - EMBER_ZCL_GP_GPDF_MOVE_UP_WITH_ON_OFF = 0x35, - EMBER_ZCL_GP_GPDF_MOVE_DOWN_WITH_ON_OFF = 0x36, - EMBER_ZCL_GP_GPDF_STEP_UP_WITH_ON_OFF = 0x37, - EMBER_ZCL_GP_GPDF_STEP_DOWN_WITH_ON_OFF = 0x38, - EMBER_ZCL_GP_GPDF_MOVE_HUE_STOP = 0x40, - EMBER_ZCL_GP_GPDF_MOVE_HUE_UP = 0x41, - EMBER_ZCL_GP_GPDF_MOVE_HUE_DOWN = 0x42, - EMBER_ZCL_GP_GPDF_STEP_HUE_UP = 0x43, - EMBER_ZCL_GP_GPDF_STEP_HUE_DOWN = 0x44, - EMBER_ZCL_GP_GPDF_MOVE_SATURATION_STOP = 0x45, - EMBER_ZCL_GP_GPDF_MOVE_SATURATION_UP = 0x46, - EMBER_ZCL_GP_GPDF_MOVE_SATURATION_DOWN = 0x47, - EMBER_ZCL_GP_GPDF_STEP_SATURATION_UP = 0x48, - EMBER_ZCL_GP_GPDF_STEP_SATURATION_DOWN = 0x49, - EMBER_ZCL_GP_GPDF_MOVE_COLOR = 0x4A, - EMBER_ZCL_GP_GPDF_STEP_COLOR = 0x4B, - EMBER_ZCL_GP_GPDF_LOCK_DOOR = 0x50, - EMBER_ZCL_GP_GPDF_UNLOCK_DOOR = 0x51, - EMBER_ZCL_GP_GPDF_PRESS1_OF1 = 0x60, - EMBER_ZCL_GP_GPDF_RELEASE1_OF1 = 0x61, - EMBER_ZCL_GP_GPDF_PRESS1_OF2 = 0x62, - EMBER_ZCL_GP_GPDF_RELEASE1_OF2 = 0x63, - EMBER_ZCL_GP_GPDF_PRESS2_OF2 = 0x64, - EMBER_ZCL_GP_GPDF_RELEASE2_OF2 = 0x65, - EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF1 = 0x66, - EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF2 = 0x67, - EMBER_ZCL_GP_GPDF_SHORT_PRESS2_OF2 = 0x68, - EMBER_ZCL_GP_GPDF_8BITS_VECTOR_PRESS = 0x69, - EMBER_ZCL_GP_GPDF_8BITS_VECTOR_RELEASE = 0x6A, - EMBER_ZCL_GP_GPDF_ATTRIBUTE_REPORTING = 0xA0, - EMBER_ZCL_GP_GPDF_MFR_SP_ATTR_RPTG = 0xA1, - EMBER_ZCL_GP_GPDF_MULTI_CLUSTER_RPTG = 0xA2, - EMBER_ZCL_GP_GPDF_MFR_SP_MULTI_CLUSTER_RPTG = 0xA3, - EMBER_ZCL_GP_GPDF_REQUEST_ATTRIBUTE = 0xA4, - EMBER_ZCL_GP_GPDF_READ_ATTR_RESPONSE = 0xA5, - EMBER_ZCL_GP_GPDF_ZCL_TUNNELING_WITH_PAYLOAD = 0xA6, - EMBER_ZCL_GP_GPDF_COMPACT_ATTRIBUTE_REPORTING = 0xA8, - EMBER_ZCL_GP_GPDF_ANY_GPD_SENSOR_CMD = 0xAF, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD0 = 0xB0, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD1 = 0xB1, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD2 = 0xB2, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD3 = 0xB3, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD4 = 0xB4, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD5 = 0xB5, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD6 = 0xB6, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD7 = 0xB7, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD8 = 0xB8, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD9 = 0xB9, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_A = 0xBA, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_B = 0xBB, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_C = 0xBC, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_D = 0xBD, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_E = 0xBE, - EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_F = 0xBF, - EMBER_ZCL_GP_GPDF_COMMISSIONING = 0xE0, - EMBER_ZCL_GP_GPDF_DECOMMISSIONING = 0xE1, - EMBER_ZCL_GP_GPDF_SUCCESS = 0xE2, - EMBER_ZCL_GP_GPDF_CHANNEL_REQUEST = 0xE3, - EMBER_ZCL_GP_GPDF_APPLICATION_DESCRIPTION = 0xE4, - EMBER_ZCL_GP_GPDF_COMMISSIONING_REPLY = 0xF0, - EMBER_ZCL_GP_GPDF_WRITE_ATTRIBUTES = 0xF1, - EMBER_ZCL_GP_GPDF_READ_ATTRIBUTES = 0xF2, - EMBER_ZCL_GP_GPDF_CHANNEL_CONFIGURATION = 0xF3, - EMBER_ZCL_GP_GPDF_ZCL_TUNNELING = 0xF6, +typedef enum +{ + EMBER_ZCL_GP_GPDF_IDENTIFY = 0x00, + EMBER_ZCL_GP_GPDF_MATCH_ONLY_ON_GPD_ADDRESS = 0x02, + EMBER_ZCL_GP_GPDF_RECALL_SCENE0 = 0x10, + EMBER_ZCL_GP_GPDF_RECALL_SCENE1 = 0x11, + EMBER_ZCL_GP_GPDF_RECALL_SCENE2 = 0x12, + EMBER_ZCL_GP_GPDF_RECALL_SCENE3 = 0x13, + EMBER_ZCL_GP_GPDF_RECALL_SCENE4 = 0x14, + EMBER_ZCL_GP_GPDF_RECALL_SCENE5 = 0x15, + EMBER_ZCL_GP_GPDF_RECALL_SCENE6 = 0x16, + EMBER_ZCL_GP_GPDF_RECALL_SCENE7 = 0x17, + EMBER_ZCL_GP_GPDF_STORE_SCENE0 = 0x18, + EMBER_ZCL_GP_GPDF_STORE_SCENE1 = 0x19, + EMBER_ZCL_GP_GPDF_STORE_SCENE2 = 0x1A, + EMBER_ZCL_GP_GPDF_STORE_SCENE3 = 0x1B, + EMBER_ZCL_GP_GPDF_STORE_SCENE4 = 0x1C, + EMBER_ZCL_GP_GPDF_STORE_SCENE5 = 0x1D, + EMBER_ZCL_GP_GPDF_STORE_SCENE6 = 0x1E, + EMBER_ZCL_GP_GPDF_STORE_SCENE7 = 0x1F, + EMBER_ZCL_GP_GPDF_OFF = 0x20, + EMBER_ZCL_GP_GPDF_ON = 0x21, + EMBER_ZCL_GP_GPDF_TOGGLE = 0x22, + EMBER_ZCL_GP_GPDF_RELEASE = 0x23, + EMBER_ZCL_GP_GPDF_MOVE_UP = 0x30, + EMBER_ZCL_GP_GPDF_MOVE_DOWN = 0x31, + EMBER_ZCL_GP_GPDF_STEP_UP = 0x32, + EMBER_ZCL_GP_GPDF_STEP_DOWN = 0x33, + EMBER_ZCL_GP_GPDF_LEVEL_CONTROL_STOP = 0x34, + EMBER_ZCL_GP_GPDF_MOVE_UP_WITH_ON_OFF = 0x35, + EMBER_ZCL_GP_GPDF_MOVE_DOWN_WITH_ON_OFF = 0x36, + EMBER_ZCL_GP_GPDF_STEP_UP_WITH_ON_OFF = 0x37, + EMBER_ZCL_GP_GPDF_STEP_DOWN_WITH_ON_OFF = 0x38, + EMBER_ZCL_GP_GPDF_MOVE_HUE_STOP = 0x40, + EMBER_ZCL_GP_GPDF_MOVE_HUE_UP = 0x41, + EMBER_ZCL_GP_GPDF_MOVE_HUE_DOWN = 0x42, + EMBER_ZCL_GP_GPDF_STEP_HUE_UP = 0x43, + EMBER_ZCL_GP_GPDF_STEP_HUE_DOWN = 0x44, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_STOP = 0x45, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_UP = 0x46, + EMBER_ZCL_GP_GPDF_MOVE_SATURATION_DOWN = 0x47, + EMBER_ZCL_GP_GPDF_STEP_SATURATION_UP = 0x48, + EMBER_ZCL_GP_GPDF_STEP_SATURATION_DOWN = 0x49, + EMBER_ZCL_GP_GPDF_MOVE_COLOR = 0x4A, + EMBER_ZCL_GP_GPDF_STEP_COLOR = 0x4B, + EMBER_ZCL_GP_GPDF_LOCK_DOOR = 0x50, + EMBER_ZCL_GP_GPDF_UNLOCK_DOOR = 0x51, + EMBER_ZCL_GP_GPDF_PRESS1_OF1 = 0x60, + EMBER_ZCL_GP_GPDF_RELEASE1_OF1 = 0x61, + EMBER_ZCL_GP_GPDF_PRESS1_OF2 = 0x62, + EMBER_ZCL_GP_GPDF_RELEASE1_OF2 = 0x63, + EMBER_ZCL_GP_GPDF_PRESS2_OF2 = 0x64, + EMBER_ZCL_GP_GPDF_RELEASE2_OF2 = 0x65, + EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF1 = 0x66, + EMBER_ZCL_GP_GPDF_SHORT_PRESS1_OF2 = 0x67, + EMBER_ZCL_GP_GPDF_SHORT_PRESS2_OF2 = 0x68, + EMBER_ZCL_GP_GPDF_8BITS_VECTOR_PRESS = 0x69, + EMBER_ZCL_GP_GPDF_8BITS_VECTOR_RELEASE = 0x6A, + EMBER_ZCL_GP_GPDF_ATTRIBUTE_REPORTING = 0xA0, + EMBER_ZCL_GP_GPDF_MFR_SP_ATTR_RPTG = 0xA1, + EMBER_ZCL_GP_GPDF_MULTI_CLUSTER_RPTG = 0xA2, + EMBER_ZCL_GP_GPDF_MFR_SP_MULTI_CLUSTER_RPTG = 0xA3, + EMBER_ZCL_GP_GPDF_REQUEST_ATTRIBUTE = 0xA4, + EMBER_ZCL_GP_GPDF_READ_ATTR_RESPONSE = 0xA5, + EMBER_ZCL_GP_GPDF_ZCL_TUNNELING_WITH_PAYLOAD = 0xA6, + EMBER_ZCL_GP_GPDF_COMPACT_ATTRIBUTE_REPORTING = 0xA8, + EMBER_ZCL_GP_GPDF_ANY_GPD_SENSOR_CMD = 0xAF, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD0 = 0xB0, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD1 = 0xB1, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD2 = 0xB2, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD3 = 0xB3, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD4 = 0xB4, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD5 = 0xB5, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD6 = 0xB6, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD7 = 0xB7, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD8 = 0xB8, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD9 = 0xB9, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_A = 0xBA, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_B = 0xBB, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_C = 0xBC, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_D = 0xBD, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_E = 0xBE, + EMBER_ZCL_GP_GPDF_MFR_DEF_GPD_CMD_F = 0xBF, + EMBER_ZCL_GP_GPDF_COMMISSIONING = 0xE0, + EMBER_ZCL_GP_GPDF_DECOMMISSIONING = 0xE1, + EMBER_ZCL_GP_GPDF_SUCCESS = 0xE2, + EMBER_ZCL_GP_GPDF_CHANNEL_REQUEST = 0xE3, + EMBER_ZCL_GP_GPDF_APPLICATION_DESCRIPTION = 0xE4, + EMBER_ZCL_GP_GPDF_COMMISSIONING_REPLY = 0xF0, + EMBER_ZCL_GP_GPDF_WRITE_ATTRIBUTES = 0xF1, + EMBER_ZCL_GP_GPDF_READ_ATTRIBUTES = 0xF2, + EMBER_ZCL_GP_GPDF_CHANNEL_CONFIGURATION = 0xF3, + EMBER_ZCL_GP_GPDF_ZCL_TUNNELING = 0xF6, } EmberAfGpGpdf; -typedef enum { - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_NO_ACTION = 0x00, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_EXTEND_SINK_TABLE_ENTRY = 0x01, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REPLACE_SINK_TABLE_ENTRY = 0x02, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_A_PAIRING = 0x03, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_GPD = 0x04, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_APPLICATION_DESCRIPTION = 0x05, +typedef enum +{ + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_NO_ACTION = 0x00, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_EXTEND_SINK_TABLE_ENTRY = 0x01, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REPLACE_SINK_TABLE_ENTRY = 0x02, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_A_PAIRING = 0x03, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_REMOVE_GPD = 0x04, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_ACTION_APPLICATION_DESCRIPTION = 0x05, } EmberAfGpPairingConfigurationAction; -typedef enum { - EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING = 0x00, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_I_D = 0x08, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMMISSIONED = 0x10, - EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING_LIGHTWEIGHT = 0x18, +typedef enum +{ + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING = 0x00, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_I_D = 0x08, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMMISSIONED = 0x10, + EMBER_ZCL_GP_PAIRING_CONFIGURATION_OPTION_COMMUNICATION_MODE_UNICAST_FORWARDING_LIGHTWEIGHT = 0x18, } EmberAfGpPairingConfigurationOptionCommunicationMode; -typedef enum { - EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_FULL_UNICAST_FORWARDING = 0x00, - EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_ID = 0x01, - EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMM_UNIT = 0x10, - EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_UNICAST_FORWARDING_BY_PROX_SUPPORT = 0x11, +typedef enum +{ + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_FULL_UNICAST_FORWARDING = 0x00, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_D_GROUP_ID = 0x01, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_GROUPCAST_FORWARDING_TO_PRE_COMM_UNIT = 0x10, + EMBER_ZCL_GP_PAIRING_OPTIONS_COMMUNICATION_MODE_UNICAST_FORWARDING_BY_PROX_SUPPORT = 0x11, } EmberAfGpPairingOptionsCommunicationMode; -typedef enum { - EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_GPD_ID = 0x00, - EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_INDEX = 0x01, +typedef enum +{ + EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_GPD_ID = 0x00, + EMBER_ZCL_GP_PROXY_TABLE_REQUEST_OPTIONS_REQUEST_TYPE_BY_INDEX = 0x01, } EmberAfGpProxyTableRequestOptionsRequestType; -typedef enum { - EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, - EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +typedef enum +{ + EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_PROXY_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, } EmberAfGpProxyTableResponseStatus; -typedef enum { - EMBER_ZCL_GP_SECURITY_KEY_TYPE_NONE = 0x00, - EMBER_ZCL_GP_SECURITY_KEY_TYPE_ZIGBEE_NETWORK_KEY = 0x01, - EMBER_ZCL_GP_SECURITY_KEY_TYPE_GPD_GROUP_KEY = 0x02, - EMBER_ZCL_GP_SECURITY_KEY_TYPE_NETWORK_DERIVED_GROUP_KEY = 0x03, - EMBER_ZCL_GP_SECURITY_KEY_TYPE_INDIVIDIGUAL_GPD_KEY = 0x04, - EMBER_ZCL_GP_SECURITY_KEY_TYPE_DERIVED_INDIVIDUAL_GPD_KEY = 0x07, +typedef enum +{ + EMBER_ZCL_GP_SECURITY_KEY_TYPE_NONE = 0x00, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_ZIGBEE_NETWORK_KEY = 0x01, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_GPD_GROUP_KEY = 0x02, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_NETWORK_DERIVED_GROUP_KEY = 0x03, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_INDIVIDIGUAL_GPD_KEY = 0x04, + EMBER_ZCL_GP_SECURITY_KEY_TYPE_DERIVED_INDIVIDUAL_GPD_KEY = 0x07, } EmberAfGpSecurityKeyType; -typedef enum { - EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_GPD_ID = 0x00, - EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_INDEX = 0x01, +typedef enum +{ + EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_GPD_ID = 0x00, + EMBER_ZCL_GP_SINK_TABLE_REQUEST_OPTIONS_REQUEST_TABLE_ENTRIES_BY_INDEX = 0x01, } EmberAfGpSinkTableRequestOptions; -typedef enum { - EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, - EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +typedef enum +{ + EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_SINK_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, } EmberAfGpSinkTableResponseStatus; -typedef enum { - EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, - EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, +typedef enum +{ + EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_SUCCESS = 0x00, + EMBER_ZCL_GP_TRANSLATION_TABLE_RESPONSE_STATUS_NOT_FOUND = 0x8B, } EmberAfGpTranslationTableResponseStatus; -typedef enum { - EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_ADD_TRANSLATION_TABLE_ENTRY = 0x00, - EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REPLACE_TRANSLATION_TABLE_ENTRY = 0x08, - EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REMOVE_TRANSLATION_TABLE_ENTRY = 0x10, - EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_RESERVED = 0x18, +typedef enum +{ + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_ADD_TRANSLATION_TABLE_ENTRY = 0x00, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REPLACE_TRANSLATION_TABLE_ENTRY = 0x08, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_REMOVE_TRANSLATION_TABLE_ENTRY = 0x10, + EMBER_ZCL_GP_TRANSLATION_TABLE_UPDATE_ACTION_RESERVED = 0x18, } EmberAfGpTranslationTableUpdateAction; -typedef enum { - EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, - EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, +typedef enum +{ + EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, + EMBER_ZCL_HEAT_AND_COOLING_SPECIFIC_ALARM_GROUPS_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, } EmberAfHeatAndCoolingSpecificAlarmGroups; -typedef enum { - EMBER_ZCL_HUE_DIRECTION_SHORTEST_DISTANCE = 0x00, - EMBER_ZCL_HUE_DIRECTION_LONGEST_DISTANCE = 0x01, - EMBER_ZCL_HUE_DIRECTION_UP = 0x02, - EMBER_ZCL_HUE_DIRECTION_DOWN = 0x03, +typedef enum +{ + EMBER_ZCL_HUE_DIRECTION_SHORTEST_DISTANCE = 0x00, + EMBER_ZCL_HUE_DIRECTION_LONGEST_DISTANCE = 0x01, + EMBER_ZCL_HUE_DIRECTION_UP = 0x02, + EMBER_ZCL_HUE_DIRECTION_DOWN = 0x03, } EmberAfHueDirection; -typedef enum { - EMBER_ZCL_HUE_MOVE_MODE_STOP = 0x00, - EMBER_ZCL_HUE_MOVE_MODE_UP = 0x01, - EMBER_ZCL_HUE_MOVE_MODE_DOWN = 0x03, +typedef enum +{ + EMBER_ZCL_HUE_MOVE_MODE_STOP = 0x00, + EMBER_ZCL_HUE_MOVE_MODE_UP = 0x01, + EMBER_ZCL_HUE_MOVE_MODE_DOWN = 0x03, } EmberAfHueMoveMode; -typedef enum { - EMBER_ZCL_HUE_STEP_MODE_UP = 0x01, - EMBER_ZCL_HUE_STEP_MODE_DOWN = 0x03, +typedef enum +{ + EMBER_ZCL_HUE_STEP_MODE_UP = 0x01, + EMBER_ZCL_HUE_STEP_MODE_DOWN = 0x03, } EmberAfHueStepMode; -typedef enum { - EMBER_ZCL_IAS_ACE_ALARM_STATUS_NO_ALARM = 0x00, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_BURGLAR = 0x01, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE = 0x02, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY = 0x03, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_POLICE_PANIC = 0x04, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE_PANIC = 0x05, - EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY_PANIC = 0x06, +typedef enum +{ + EMBER_ZCL_IAS_ACE_ALARM_STATUS_NO_ALARM = 0x00, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_BURGLAR = 0x01, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE = 0x02, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY = 0x03, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_POLICE_PANIC = 0x04, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_FIRE_PANIC = 0x05, + EMBER_ZCL_IAS_ACE_ALARM_STATUS_EMERGENCY_PANIC = 0x06, } EmberAfIasAceAlarmStatus; -typedef enum { - EMBER_ZCL_IAS_ACE_ARM_MODE_DISARM = 0x00, - EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_DAY_HOME_ZONES_ONLY = 0x01, - EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_NIGHT_SLEEP_ZONES_ONLY = 0x02, - EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_ALL_ZONES = 0x03, +typedef enum +{ + EMBER_ZCL_IAS_ACE_ARM_MODE_DISARM = 0x00, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_DAY_HOME_ZONES_ONLY = 0x01, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_NIGHT_SLEEP_ZONES_ONLY = 0x02, + EMBER_ZCL_IAS_ACE_ARM_MODE_ARM_ALL_ZONES = 0x03, } EmberAfIasAceArmMode; -typedef enum { - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_DISARMED = 0x00, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_DAY_HOME_ZONES_ARMED = 0x01, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_NIGHT_SLEEP_ZONES_ARMED = 0x02, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_ARMED = 0x03, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_INVALID_ARM_DISARM_CODE = 0x04, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_NOT_READY_TO_ARM = 0x05, - EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALREADY_DISARMED = 0x06, +typedef enum +{ + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_DISARMED = 0x00, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_DAY_HOME_ZONES_ARMED = 0x01, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ONLY_NIGHT_SLEEP_ZONES_ARMED = 0x02, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALL_ZONES_ARMED = 0x03, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_INVALID_ARM_DISARM_CODE = 0x04, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_NOT_READY_TO_ARM = 0x05, + EMBER_ZCL_IAS_ACE_ARM_NOTIFICATION_ALREADY_DISARMED = 0x06, } EmberAfIasAceArmNotification; -typedef enum { - EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_MUTE = 0x00, - EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_DEFAULT_SOUND = 0x01, +typedef enum +{ + EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_MUTE = 0x00, + EMBER_ZCL_IAS_ACE_AUDIBLE_NOTIFICATION_DEFAULT_SOUND = 0x01, } EmberAfIasAceAudibleNotification; -typedef enum { - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_BYPASSED = 0x00, - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_NOT_BYPASSED = 0x01, - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_NOT_ALLOWED = 0x02, - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ZONE_ID = 0x03, - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_UNKNOWN_ZONE_ID = 0x04, - EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ARM_DISARM_CODE = 0x05, +typedef enum +{ + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_BYPASSED = 0x00, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_ZONE_NOT_BYPASSED = 0x01, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_NOT_ALLOWED = 0x02, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ZONE_ID = 0x03, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_UNKNOWN_ZONE_ID = 0x04, + EMBER_ZCL_IAS_ACE_BYPASS_RESULT_INVALID_ARM_DISARM_CODE = 0x05, } EmberAfIasAceBypassResult; -typedef enum { - EMBER_ZCL_IAS_ACE_PANEL_STATUS_PANEL_DISARMED = 0x00, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_STAY = 0x01, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_NIGHT = 0x02, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_AWAY = 0x03, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_EXIT_DELAY = 0x04, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ENTRY_DELAY = 0x05, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_NOT_READY_TO_ARM = 0x06, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_IN_ALARM = 0x07, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_STAY = 0x08, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_NIGHT = 0x09, - EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_AWAY = 0x0A, +typedef enum +{ + EMBER_ZCL_IAS_ACE_PANEL_STATUS_PANEL_DISARMED = 0x00, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_STAY = 0x01, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_NIGHT = 0x02, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMED_AWAY = 0x03, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_EXIT_DELAY = 0x04, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ENTRY_DELAY = 0x05, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_NOT_READY_TO_ARM = 0x06, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_IN_ALARM = 0x07, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_STAY = 0x08, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_NIGHT = 0x09, + EMBER_ZCL_IAS_ACE_PANEL_STATUS_ARMING_AWAY = 0x0A, } EmberAfIasAcePanelStatus; -typedef enum { - EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_SUCCESS = 0x00, - EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NOT_SUPPORTED = 0x01, - EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NO_ENROLL_PERMIT = 0x02, - EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_TOO_MANY_ZONES = 0x03, +typedef enum +{ + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_SUCCESS = 0x00, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NOT_SUPPORTED = 0x01, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_NO_ENROLL_PERMIT = 0x02, + EMBER_ZCL_IAS_ENROLL_RESPONSE_CODE_TOO_MANY_ZONES = 0x03, } EmberAfIasEnrollResponseCode; -typedef enum { - EMBER_ZCL_IAS_ZONE_STATE_NOT_ENROLLED = 0x00, - EMBER_ZCL_IAS_ZONE_STATE_ENROLLED = 0x01, +typedef enum +{ + EMBER_ZCL_IAS_ZONE_STATE_NOT_ENROLLED = 0x00, + EMBER_ZCL_IAS_ZONE_STATE_ENROLLED = 0x01, } EmberAfIasZoneState; -typedef enum { - EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_CIE = 0x0000, - EMBER_ZCL_IAS_ZONE_TYPE_MOTION_SENSOR = 0x000D, - EMBER_ZCL_IAS_ZONE_TYPE_CONTACT_SWITCH = 0x0015, - EMBER_ZCL_IAS_ZONE_TYPE_FIRE_SENSOR = 0x0028, - EMBER_ZCL_IAS_ZONE_TYPE_WATER_SENSOR = 0x002A, - EMBER_ZCL_IAS_ZONE_TYPE_GAS_SENSOR = 0x002B, - EMBER_ZCL_IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x002C, - EMBER_ZCL_IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x002D, - EMBER_ZCL_IAS_ZONE_TYPE_REMOTE_CONTROL = 0x010F, - EMBER_ZCL_IAS_ZONE_TYPE_KEY_FOB = 0x0115, - EMBER_ZCL_IAS_ZONE_TYPE_KEYPAD = 0x021D, - EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE = 0x0225, - EMBER_ZCL_IAS_ZONE_TYPE_GLASS_BREAK_SENSOR = 0x0226, - EMBER_ZCL_IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR = 0x0227, - EMBER_ZCL_IAS_ZONE_TYPE_SECURITY_REPEATER = 0x0229, - EMBER_ZCL_IAS_ZONE_TYPE_INVALID_ZONE_TYPE = 0xFFFF, +typedef enum +{ + EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_CIE = 0x0000, + EMBER_ZCL_IAS_ZONE_TYPE_MOTION_SENSOR = 0x000D, + EMBER_ZCL_IAS_ZONE_TYPE_CONTACT_SWITCH = 0x0015, + EMBER_ZCL_IAS_ZONE_TYPE_FIRE_SENSOR = 0x0028, + EMBER_ZCL_IAS_ZONE_TYPE_WATER_SENSOR = 0x002A, + EMBER_ZCL_IAS_ZONE_TYPE_GAS_SENSOR = 0x002B, + EMBER_ZCL_IAS_ZONE_TYPE_PERSONAL_EMERGENCY_DEVICE = 0x002C, + EMBER_ZCL_IAS_ZONE_TYPE_VIBRATION_MOVEMENT_SENSOR = 0x002D, + EMBER_ZCL_IAS_ZONE_TYPE_REMOTE_CONTROL = 0x010F, + EMBER_ZCL_IAS_ZONE_TYPE_KEY_FOB = 0x0115, + EMBER_ZCL_IAS_ZONE_TYPE_KEYPAD = 0x021D, + EMBER_ZCL_IAS_ZONE_TYPE_STANDARD_WARNING_DEVICE = 0x0225, + EMBER_ZCL_IAS_ZONE_TYPE_GLASS_BREAK_SENSOR = 0x0226, + EMBER_ZCL_IAS_ZONE_TYPE_CARBON_MONOXIDE_SENSOR = 0x0227, + EMBER_ZCL_IAS_ZONE_TYPE_SECURITY_REPEATER = 0x0229, + EMBER_ZCL_IAS_ZONE_TYPE_INVALID_ZONE_TYPE = 0xFFFF, } EmberAfIasZoneType; -typedef enum { - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK = 0x00, - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE = 0x01, - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY = 0x02, - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE = 0x0B, - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_FINISH_EFFECT = 0xFE, - EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_STOP_EFFECT = 0xFF, +typedef enum +{ + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK = 0x00, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE = 0x01, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY = 0x02, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE = 0x0B, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_FINISH_EFFECT = 0xFE, + EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_STOP_EFFECT = 0xFF, } EmberAfIdentifyEffectIdentifier; -typedef enum { - EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT = 0x00, +typedef enum +{ + EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT = 0x00, } EmberAfIdentifyEffectVariant; -typedef enum { - EMBER_ZCL_KEY_INDEX_DEVELOPMENT = 0x00, - EMBER_ZCL_KEY_INDEX_MASTER = 0x04, - EMBER_ZCL_KEY_INDEX_CERTIFICATION = 0x0F, +typedef enum +{ + EMBER_ZCL_KEY_INDEX_DEVELOPMENT = 0x00, + EMBER_ZCL_KEY_INDEX_MASTER = 0x04, + EMBER_ZCL_KEY_INDEX_CERTIFICATION = 0x0F, } EmberAfKeyIndex; -typedef enum { - EMBER_ZCL_KEYPAD_LOCKOUT_NO_LOCKOUT = 0x00, - EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_ONE_LOCKOUT = 0x01, - EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_TWO_LOCKOUT = 0x02, - EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_THREE_LOCKOUT = 0x03, - EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_FOUR_LOCKOUT = 0x04, - EMBER_ZCL_KEYPAD_LOCKOUT_LEVELFIVE_LOCKOUT = 0x05, +typedef enum +{ + EMBER_ZCL_KEYPAD_LOCKOUT_NO_LOCKOUT = 0x00, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_ONE_LOCKOUT = 0x01, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_TWO_LOCKOUT = 0x02, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_THREE_LOCKOUT = 0x03, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVEL_FOUR_LOCKOUT = 0x04, + EMBER_ZCL_KEYPAD_LOCKOUT_LEVELFIVE_LOCKOUT = 0x05, } EmberAfKeypadLockout; -typedef enum { - EMBER_ZCL_LEVEL_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, - EMBER_ZCL_LEVEL_CONTROL_OPTIONS_COUPLE_COLOR_TEMP_TO_LEVEL = 0x02, +typedef enum +{ + EMBER_ZCL_LEVEL_CONTROL_OPTIONS_EXECUTE_IF_OFF = 0x01, + EMBER_ZCL_LEVEL_CONTROL_OPTIONS_COUPLE_COLOR_TEMP_TO_LEVEL = 0x02, } EmberAfLevelControlOptions; -typedef enum { - EMBER_ZCL_LEVEL_STATUS_ON_TARGET = 0x00, - EMBER_ZCL_LEVEL_STATUS_BELOW_TARGET = 0x01, - EMBER_ZCL_LEVEL_STATUS_ABOVE_TARGET = 0x02, +typedef enum +{ + EMBER_ZCL_LEVEL_STATUS_ON_TARGET = 0x00, + EMBER_ZCL_LEVEL_STATUS_BELOW_TARGET = 0x01, + EMBER_ZCL_LEVEL_STATUS_ABOVE_TARGET = 0x02, } EmberAfLevelStatus; -typedef enum { - EMBER_ZCL_LOCATION_METHOD_LATERATION = 0x00, - EMBER_ZCL_LOCATION_METHOD_SIGNPOSTING = 0x01, - EMBER_ZCL_LOCATION_METHOD_RF_FINGERPRINTING = 0x02, - EMBER_ZCL_LOCATION_METHOD_OUT_OF_BAND = 0x03, +typedef enum +{ + EMBER_ZCL_LOCATION_METHOD_LATERATION = 0x00, + EMBER_ZCL_LOCATION_METHOD_SIGNPOSTING = 0x01, + EMBER_ZCL_LOCATION_METHOD_RF_FINGERPRINTING = 0x02, + EMBER_ZCL_LOCATION_METHOD_OUT_OF_BAND = 0x03, } EmberAfLocationMethod; -typedef enum { - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_A = 0xB0, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_B = 0xB1, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_C = 0xB2, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_D = 0xB3, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_E = 0xB4, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_F = 0xB5, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_G = 0xB6, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_H = 0xB7, - EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_I = 0xB8, +typedef enum +{ + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_A = 0xB0, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_B = 0xB1, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_C = 0xB2, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_D = 0xB3, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_E = 0xB4, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_F = 0xB5, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_G = 0xB6, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_H = 0xB7, + EMBER_ZCL_MANUFACTURER_SPECIFIC_ALARM_GROUPS_MANUFACTURER_SPECIFIC_I = 0xB8, } EmberAfManufacturerSpecificAlarmGroups; -typedef enum { - EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, - EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_CMOS = 0x01, +typedef enum +{ + EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, + EMBER_ZCL_MEASUREMENT_LIGHT_SENSOR_TYPE_CMOS = 0x01, } EmberAfMeasurementLightSensorType; -typedef enum { - EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_NOT_REQUIRED = 0x00, - EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_REQUIRED = 0x80, +typedef enum +{ + EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_NOT_REQUIRED = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_CONFIRMATION_REQUIRED = 0x80, } EmberAfMessagingControlConfirmation; -typedef enum { - EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_NOT_REQUIRED = 0x00, - EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_REQUIRED = 0x20, -} EmberAfMessagingControlEnhancedConfirmation ; - -typedef enum { - EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_LOW = 0x00, - EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_MEDIUM = 0x04, - EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_HIGH = 0x08, - EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_CRITICAL = 0x0C, +typedef enum +{ + EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_NOT_REQUIRED = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_ENHANCED_CONFIRMATION_REQUIRED = 0x20, +} EmberAfMessagingControlEnhancedConfirmation; + +typedef enum +{ + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_LOW = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_MEDIUM = 0x04, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_HIGH = 0x08, + EMBER_ZCL_MESSAGING_CONTROL_IMPORTANCE_CRITICAL = 0x0C, } EmberAfMessagingControlImportance; -typedef enum { - EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL = 0x00, - EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL_AND_ANONYMOUS = 0x01, - EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_ANONYMOUS = 0x02, - EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_RESERVED = 0x03, +typedef enum +{ + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL = 0x00, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_NORMAL_AND_ANONYMOUS = 0x01, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_ANONYMOUS = 0x02, + EMBER_ZCL_MESSAGING_CONTROL_TRANSMISSION_RESERVED = 0x03, } EmberAfMessagingControlTransmission; -typedef enum { - EMBER_ZCL_METER_DEVICE_TYPE_ELECTRIC_METER = 0x00, - EMBER_ZCL_METER_DEVICE_TYPE_GAS_METER = 0x01, - EMBER_ZCL_METER_DEVICE_TYPE_WATER_METER = 0x02, - EMBER_ZCL_METER_DEVICE_TYPE_THERMAL_METER = 0x03, - EMBER_ZCL_METER_DEVICE_TYPE_PRESSURE_METER = 0x04, - EMBER_ZCL_METER_DEVICE_TYPE_HEAT_METER = 0x05, - EMBER_ZCL_METER_DEVICE_TYPE_COOLING_METER = 0x06, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_GAS_METER = 0x80, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_WATER_METER = 0x81, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_THERMAL_METER = 0x82, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_PRESSURE_METER = 0x83, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_HEAT_METER = 0x84, - EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_COOLING_METER = 0x85, - EMBER_ZCL_METER_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, +typedef enum +{ + EMBER_ZCL_METER_DEVICE_TYPE_ELECTRIC_METER = 0x00, + EMBER_ZCL_METER_DEVICE_TYPE_GAS_METER = 0x01, + EMBER_ZCL_METER_DEVICE_TYPE_WATER_METER = 0x02, + EMBER_ZCL_METER_DEVICE_TYPE_THERMAL_METER = 0x03, + EMBER_ZCL_METER_DEVICE_TYPE_PRESSURE_METER = 0x04, + EMBER_ZCL_METER_DEVICE_TYPE_HEAT_METER = 0x05, + EMBER_ZCL_METER_DEVICE_TYPE_COOLING_METER = 0x06, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_GAS_METER = 0x80, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_WATER_METER = 0x81, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_THERMAL_METER = 0x82, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_PRESSURE_METER = 0x83, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_HEAT_METER = 0x84, + EMBER_ZCL_METER_DEVICE_TYPE_MIRRORED_COOLING_METER = 0x85, + EMBER_ZCL_METER_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, } EmberAfMeterDeviceType; -typedef enum { - EMBER_ZCL_METER_TYPE_ID_UTILITY_PRIMARY_METER = 0x0000, - EMBER_ZCL_METER_TYPE_ID_UTILITY_PRODUCTION_METER = 0x0001, - EMBER_ZCL_METER_TYPE_ID_UTILITY_SECONDARY_METER = 0x0002, - EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRIMARY_METER = 0x0100, - EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRODUCTION_METER = 0x0101, - EMBER_ZCL_METER_TYPE_ID_PRIVATE_SECONDARY_METERS = 0x0102, - EMBER_ZCL_METER_TYPE_ID_GENERIC_METER = 0x0110, +typedef enum +{ + EMBER_ZCL_METER_TYPE_ID_UTILITY_PRIMARY_METER = 0x0000, + EMBER_ZCL_METER_TYPE_ID_UTILITY_PRODUCTION_METER = 0x0001, + EMBER_ZCL_METER_TYPE_ID_UTILITY_SECONDARY_METER = 0x0002, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRIMARY_METER = 0x0100, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_PRODUCTION_METER = 0x0101, + EMBER_ZCL_METER_TYPE_ID_PRIVATE_SECONDARY_METERS = 0x0102, + EMBER_ZCL_METER_TYPE_ID_GENERIC_METER = 0x0110, } EmberAfMeterTypeId; -typedef enum { - EMBER_ZCL_METERING_ALARM_CODE_CHECK_METER = 0x00, - EMBER_ZCL_METERING_ALARM_CODE_LOW_BATTERY = 0x01, - EMBER_ZCL_METERING_ALARM_CODE_TAMPER_DETECT = 0x02, - EMBER_ZCL_METERING_ALARM_CODE_POWER_FAILURE_PIPE_EMPTY_TEMPERATURE_SENSOR = 0x03, - EMBER_ZCL_METERING_ALARM_CODE_POWER_QUALITY_LOW_PRESSURE_BURST_DETECT = 0x04, - EMBER_ZCL_METERING_ALARM_CODE_LEAK_DETECT = 0x05, - EMBER_ZCL_METERING_ALARM_CODE_SERVICE_DISCONNECT = 0x06, - EMBER_ZCL_METERING_ALARM_CODE_REVERSE_FLOW_FLOW_SENSOR = 0x07, - EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_REMOVED = 0x08, - EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_CLOSED = 0x09, - EMBER_ZCL_METERING_ALARM_CODE_STRONG_MAGNETIC_FIELD = 0x0A, - EMBER_ZCL_METERING_ALARM_CODE_NO_STRONG_MAGNETIC_FIELD = 0x0B, - EMBER_ZCL_METERING_ALARM_CODE_BATTERY_FAILURE = 0x0C, - EMBER_ZCL_METERING_ALARM_CODE_PROGRAM_MEMORY_ERROR = 0x0D, - EMBER_ZCL_METERING_ALARM_CODE_R_A_M_ERROR = 0x0E, - EMBER_ZCL_METERING_ALARM_CODE_N_V_MEMORY_ERROR = 0x0F, - EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L1 = 0x10, - EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L1 = 0x11, - EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L2 = 0x12, - EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L2 = 0x13, - EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L3 = 0x14, - EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L3 = 0x15, - EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L1 = 0x16, - EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L2 = 0x17, - EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L3 = 0x18, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L1 = 0x19, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L1 = 0x1A, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L2 = 0x1B, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L2 = 0x1C, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L3 = 0x1D, - EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L3 = 0x1E, - EMBER_ZCL_METERING_ALARM_CODE_GROUND_FAULT = 0x1F, - EMBER_ZCL_METERING_ALARM_CODE_ELECTRIC_TAMPER_DETECT = 0x20, - EMBER_ZCL_METERING_ALARM_CODE_INCORRECT_POLARITY = 0x21, - EMBER_ZCL_METERING_ALARM_CODE_CURRENT_NO_VOLTAGE = 0x22, - EMBER_ZCL_METERING_ALARM_CODE_UNDER_VOLTAGE = 0x23, - EMBER_ZCL_METERING_ALARM_CODE_OVER_VOLTAGE = 0x24, - EMBER_ZCL_METERING_ALARM_CODE_NORMAL_VOLTAGE = 0x25, - EMBER_ZCL_METERING_ALARM_CODE_P_F_BELOW_THRESHOLD = 0x26, - EMBER_ZCL_METERING_ALARM_CODE_P_F_ABOVE_THRESHOLD = 0x27, - EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_REMOVED = 0x28, - EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_CLOSED = 0x29, - EMBER_ZCL_METERING_ALARM_CODE_BURST_DETECT = 0x30, - EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_LOW = 0x31, - EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_HIGH = 0x32, - EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, - EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, - EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_REVERSE_FLOW = 0x35, - EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_AIR_DETECT = 0x36, - EMBER_ZCL_METERING_ALARM_CODE_PIPE_EMPTY = 0x37, - EMBER_ZCL_METERING_ALARM_CODE_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, - EMBER_ZCL_METERING_ALARM_CODE_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, - EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER = 0x60, - EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_REMOVED = 0x61, - EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_CLOSED = 0x62, - EMBER_ZCL_METERING_ALARM_CODE_EXCESS_FLOW = 0x63, - EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER_ENDED = 0x64, - EMBER_ZCL_METERING_ALARM_CODE_MEASUREMENT_SYSTEM_ERROR = 0x70, - EMBER_ZCL_METERING_ALARM_CODE_WATCHDOG_ERROR = 0x71, - EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_DISCONNECT_FAILURE = 0x72, - EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_CONNECT_FAILURE = 0x73, - EMBER_ZCL_METERING_ALARM_CODE_MEASURMENT_SOFTWARE_CHANGED = 0x74, - EMBER_ZCL_METERING_ALARM_CODE_DST_ENABLED = 0x75, - EMBER_ZCL_METERING_ALARM_CODE_DST_DISABLED = 0x76, - EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_BACKWARD = 0x77, - EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_FORWARD = 0x78, - EMBER_ZCL_METERING_ALARM_CODE_CLOCK_INVALID = 0x79, - EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_ERROR_HAN = 0x7A, - EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_OK_H_AN = 0x7B, - EMBER_ZCL_METERING_ALARM_CODE_METER_FRAUD_ATTEMPT = 0x7C, - EMBER_ZCL_METERING_ALARM_CODE_POWER_LOSS = 0x7D, - EMBER_ZCL_METERING_ALARM_CODE_UNUSUAL_HAN_TRAFFIC = 0x7E, - EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_CLOCK_CHANGE = 0x7F, - EMBER_ZCL_METERING_ALARM_CODE_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, - EMBER_ZCL_METERING_ALARM_CODE_ERROR_REG_CLEAR = 0x81, - EMBER_ZCL_METERING_ALARM_CODE_ALARM_REG_CLEAR = 0x82, - EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_HW_RESET = 0x83, - EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_PROGRAM_EXECUTION = 0x84, - EMBER_ZCL_METERING_ALARM_CODE_EVENT_LOG_CLEARED = 0x85, - EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_EXCEEDED = 0x86, - EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_OK = 0x87, - EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_CHANGED = 0x88, - EMBER_ZCL_METERING_ALARM_CODE_MAXIMUM_DEMAND_EXCEEDED = 0x89, - EMBER_ZCL_METERING_ALARM_CODE_PROFILE_CLEARED = 0x8A, - EMBER_ZCL_METERING_ALARM_CODE_SAMPLING_BUFFERCLEARED = 0x8B, - EMBER_ZCL_METERING_ALARM_CODE_BATTERY_WARNING = 0x8C, - EMBER_ZCL_METERING_ALARM_CODE_WRONG_SIGNATURE = 0x8D, - EMBER_ZCL_METERING_ALARM_CODE_NO_SIGNATURE = 0x8E, - EMBER_ZCL_METERING_ALARM_CODE_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, - EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_START = 0x90, - EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_END = 0x91, - EMBER_ZCL_METERING_ALARM_CODE_METER_REPORTING_INTERVAL_CHANGED = 0x92, - EMBER_ZCL_METERING_ALARM_CODE_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, - EMBER_ZCL_METERING_ALARM_CODE_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, - EMBER_ZCL_METERING_ALARM_CODE_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, - EMBER_ZCL_METERING_ALARM_CODE_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_A = 0xB0, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_B = 0xB1, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_C = 0xB2, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_D = 0xB3, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_E = 0xB4, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_F = 0xB5, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_G = 0xB6, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_H = 0xB7, - EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_I = 0xB8, +typedef enum +{ + EMBER_ZCL_METERING_ALARM_CODE_CHECK_METER = 0x00, + EMBER_ZCL_METERING_ALARM_CODE_LOW_BATTERY = 0x01, + EMBER_ZCL_METERING_ALARM_CODE_TAMPER_DETECT = 0x02, + EMBER_ZCL_METERING_ALARM_CODE_POWER_FAILURE_PIPE_EMPTY_TEMPERATURE_SENSOR = 0x03, + EMBER_ZCL_METERING_ALARM_CODE_POWER_QUALITY_LOW_PRESSURE_BURST_DETECT = 0x04, + EMBER_ZCL_METERING_ALARM_CODE_LEAK_DETECT = 0x05, + EMBER_ZCL_METERING_ALARM_CODE_SERVICE_DISCONNECT = 0x06, + EMBER_ZCL_METERING_ALARM_CODE_REVERSE_FLOW_FLOW_SENSOR = 0x07, + EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_REMOVED = 0x08, + EMBER_ZCL_METERING_ALARM_CODE_METER_COVER_CLOSED = 0x09, + EMBER_ZCL_METERING_ALARM_CODE_STRONG_MAGNETIC_FIELD = 0x0A, + EMBER_ZCL_METERING_ALARM_CODE_NO_STRONG_MAGNETIC_FIELD = 0x0B, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_FAILURE = 0x0C, + EMBER_ZCL_METERING_ALARM_CODE_PROGRAM_MEMORY_ERROR = 0x0D, + EMBER_ZCL_METERING_ALARM_CODE_R_A_M_ERROR = 0x0E, + EMBER_ZCL_METERING_ALARM_CODE_N_V_MEMORY_ERROR = 0x0F, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L1 = 0x10, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L1 = 0x11, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L2 = 0x12, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L2 = 0x13, + EMBER_ZCL_METERING_ALARM_CODE_LOW_VOLTAGE_L3 = 0x14, + EMBER_ZCL_METERING_ALARM_CODE_HIGH_VOLTAGE_L3 = 0x15, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L1 = 0x16, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L2 = 0x17, + EMBER_ZCL_METERING_ALARM_CODE_OVER_CURRENT_L3 = 0x18, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L1 = 0x19, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L1 = 0x1A, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L2 = 0x1B, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L2 = 0x1C, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_LOW_L3 = 0x1D, + EMBER_ZCL_METERING_ALARM_CODE_FREQUENCY_TOO_HIGH_L3 = 0x1E, + EMBER_ZCL_METERING_ALARM_CODE_GROUND_FAULT = 0x1F, + EMBER_ZCL_METERING_ALARM_CODE_ELECTRIC_TAMPER_DETECT = 0x20, + EMBER_ZCL_METERING_ALARM_CODE_INCORRECT_POLARITY = 0x21, + EMBER_ZCL_METERING_ALARM_CODE_CURRENT_NO_VOLTAGE = 0x22, + EMBER_ZCL_METERING_ALARM_CODE_UNDER_VOLTAGE = 0x23, + EMBER_ZCL_METERING_ALARM_CODE_OVER_VOLTAGE = 0x24, + EMBER_ZCL_METERING_ALARM_CODE_NORMAL_VOLTAGE = 0x25, + EMBER_ZCL_METERING_ALARM_CODE_P_F_BELOW_THRESHOLD = 0x26, + EMBER_ZCL_METERING_ALARM_CODE_P_F_ABOVE_THRESHOLD = 0x27, + EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_REMOVED = 0x28, + EMBER_ZCL_METERING_ALARM_CODE_TERMINAL_COVER_CLOSED = 0x29, + EMBER_ZCL_METERING_ALARM_CODE_BURST_DETECT = 0x30, + EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_LOW = 0x31, + EMBER_ZCL_METERING_ALARM_CODE_PRESSURE_TOO_HIGH = 0x32, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_COMMUNICATION_ERROR = 0x33, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_MEASUREMENT_FAULT = 0x34, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_REVERSE_FLOW = 0x35, + EMBER_ZCL_METERING_ALARM_CODE_FLOW_SENSOR_AIR_DETECT = 0x36, + EMBER_ZCL_METERING_ALARM_CODE_PIPE_EMPTY = 0x37, + EMBER_ZCL_METERING_ALARM_CODE_INLET_TEMPERATURE_SENSOR_FAULT = 0x50, + EMBER_ZCL_METERING_ALARM_CODE_OUTLET_TEMPERATURE_SENSOR_FAULT = 0x51, + EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER = 0x60, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_REMOVED = 0x61, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_COVER_CLOSED = 0x62, + EMBER_ZCL_METERING_ALARM_CODE_EXCESS_FLOW = 0x63, + EMBER_ZCL_METERING_ALARM_CODE_TILT_TAMPER_ENDED = 0x64, + EMBER_ZCL_METERING_ALARM_CODE_MEASUREMENT_SYSTEM_ERROR = 0x70, + EMBER_ZCL_METERING_ALARM_CODE_WATCHDOG_ERROR = 0x71, + EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_DISCONNECT_FAILURE = 0x72, + EMBER_ZCL_METERING_ALARM_CODE_SUPPLY_CONNECT_FAILURE = 0x73, + EMBER_ZCL_METERING_ALARM_CODE_MEASURMENT_SOFTWARE_CHANGED = 0x74, + EMBER_ZCL_METERING_ALARM_CODE_DST_ENABLED = 0x75, + EMBER_ZCL_METERING_ALARM_CODE_DST_DISABLED = 0x76, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_BACKWARD = 0x77, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_ADJ_FORWARD = 0x78, + EMBER_ZCL_METERING_ALARM_CODE_CLOCK_INVALID = 0x79, + EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_ERROR_HAN = 0x7A, + EMBER_ZCL_METERING_ALARM_CODE_COMMUNICATION_OK_H_AN = 0x7B, + EMBER_ZCL_METERING_ALARM_CODE_METER_FRAUD_ATTEMPT = 0x7C, + EMBER_ZCL_METERING_ALARM_CODE_POWER_LOSS = 0x7D, + EMBER_ZCL_METERING_ALARM_CODE_UNUSUAL_HAN_TRAFFIC = 0x7E, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_CLOCK_CHANGE = 0x7F, + EMBER_ZCL_METERING_ALARM_CODE_COMMS_USING_UNAUTHENTICATED_COMPONENT = 0x80, + EMBER_ZCL_METERING_ALARM_CODE_ERROR_REG_CLEAR = 0x81, + EMBER_ZCL_METERING_ALARM_CODE_ALARM_REG_CLEAR = 0x82, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_HW_RESET = 0x83, + EMBER_ZCL_METERING_ALARM_CODE_UNEXPECTED_PROGRAM_EXECUTION = 0x84, + EMBER_ZCL_METERING_ALARM_CODE_EVENT_LOG_CLEARED = 0x85, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_EXCEEDED = 0x86, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_OK = 0x87, + EMBER_ZCL_METERING_ALARM_CODE_LIMIT_THRESHOLD_CHANGED = 0x88, + EMBER_ZCL_METERING_ALARM_CODE_MAXIMUM_DEMAND_EXCEEDED = 0x89, + EMBER_ZCL_METERING_ALARM_CODE_PROFILE_CLEARED = 0x8A, + EMBER_ZCL_METERING_ALARM_CODE_SAMPLING_BUFFERCLEARED = 0x8B, + EMBER_ZCL_METERING_ALARM_CODE_BATTERY_WARNING = 0x8C, + EMBER_ZCL_METERING_ALARM_CODE_WRONG_SIGNATURE = 0x8D, + EMBER_ZCL_METERING_ALARM_CODE_NO_SIGNATURE = 0x8E, + EMBER_ZCL_METERING_ALARM_CODE_UNAUTHORISED_ACTIONFROM_HAN = 0x8F, + EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_START = 0x90, + EMBER_ZCL_METERING_ALARM_CODE_FAST_POLLING_END = 0x91, + EMBER_ZCL_METERING_ALARM_CODE_METER_REPORTING_INTERVAL_CHANGED = 0x92, + EMBER_ZCL_METERING_ALARM_CODE_DISCONNECT_DUETO_LOAD_LIMIT = 0x93, + EMBER_ZCL_METERING_ALARM_CODE_METER_SUPPLY_STATUS_REGISTER_CHANGED = 0x94, + EMBER_ZCL_METERING_ALARM_CODE_METER_ALARM_STATUS_REGISTER_CHANGED = 0x95, + EMBER_ZCL_METERING_ALARM_CODE_EXTENDED_METER_ALARM_STATUS_REGISTER_CHANGED = 0x96, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_A = 0xB0, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_B = 0xB1, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_C = 0xB2, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_D = 0xB3, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_E = 0xB4, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_F = 0xB5, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_G = 0xB6, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_H = 0xB7, + EMBER_ZCL_METERING_ALARM_CODE_MANUFACTURER_SPECIFIC_I = 0xB8, } EmberAfMeteringAlarmCode; -typedef enum { - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_NO_BLOCKS_IN_USE = 0x00, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK1 = 0x01, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK2 = 0x02, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK3 = 0x03, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK4 = 0x04, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK5 = 0x05, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK6 = 0x06, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK7 = 0x07, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK8 = 0x08, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK9 = 0x09, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK10 = 0x0A, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK11 = 0x0B, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK12 = 0x0C, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK13 = 0x0D, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK14 = 0x0E, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK15 = 0x0F, - EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK16 = 0x10, +typedef enum +{ + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_NO_BLOCKS_IN_USE = 0x00, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK1 = 0x01, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK2 = 0x02, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK3 = 0x03, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK4 = 0x04, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK5 = 0x05, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK6 = 0x06, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK7 = 0x07, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK8 = 0x08, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK9 = 0x09, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK10 = 0x0A, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK11 = 0x0B, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK12 = 0x0C, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK13 = 0x0D, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK14 = 0x0E, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK15 = 0x0F, + EMBER_ZCL_METERING_BLOCK_ENUMERATIONS_BLOCK16 = 0x10, } EmberAfMeteringBlockEnumerations; -typedef enum { - EMBER_ZCL_METERING_CONSUMPTION_STATUS_LOW_ENERGY_USAGE = 0x00, - EMBER_ZCL_METERING_CONSUMPTION_STATUS_MEDIUM_ENERGY_USAGE = 0x01, - EMBER_ZCL_METERING_CONSUMPTION_STATUS_HIGH_ENERGY_USAGE = 0x02, +typedef enum +{ + EMBER_ZCL_METERING_CONSUMPTION_STATUS_LOW_ENERGY_USAGE = 0x00, + EMBER_ZCL_METERING_CONSUMPTION_STATUS_MEDIUM_ENERGY_USAGE = 0x01, + EMBER_ZCL_METERING_CONSUMPTION_STATUS_HIGH_ENERGY_USAGE = 0x02, } EmberAfMeteringConsumptionStatus; -typedef enum { - EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING = 0x00, - EMBER_ZCL_METERING_DEVICE_TYPE_GAS_METERING = 0x01, - EMBER_ZCL_METERING_DEVICE_TYPE_WATER_METERING = 0x02, - EMBER_ZCL_METERING_DEVICE_TYPE_THERMAL_METERING = 0x03, - EMBER_ZCL_METERING_DEVICE_TYPE_PRESSURE_METERING = 0x04, - EMBER_ZCL_METERING_DEVICE_TYPE_HEAT_METERING = 0x05, - EMBER_ZCL_METERING_DEVICE_TYPE_COOLING_METERING = 0x06, - EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, - EMBER_ZCL_METERING_DEVICE_TYPE_PV_GENERATION_METERING = 0x08, - EMBER_ZCL_METERING_DEVICE_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, - EMBER_ZCL_METERING_DEVICE_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, - EMBER_ZCL_METERING_DEVICE_TYPE_MICRO_GENERATION_METERING = 0x0B, - EMBER_ZCL_METERING_DEVICE_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, - EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, - EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, - EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING = 0x7F, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_GAS_METERING = 0x80, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_METERING = 0x81, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_THERMAL_METERING = 0x82, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PRESSURE_METERING = 0x83, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_HEAT_METERING = 0x84, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_COOLING_METERING = 0x85, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_VEHICLE_CHARGING_METERING = 0x86, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PV_GENERATION_METERING = 0x87, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WIND_TURBINE_GENERATION_METERING = 0x88, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_TURBINE_GENERATION_METERING = 0x89, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_MICRO_GENERATION_METERING = 0x8A, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_SOLAR_HOT_WATER_GENERATION_METERING = 0x8B, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT1 = 0x8C, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT2 = 0x8D, - EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT3 = 0x8E, - EMBER_ZCL_METERING_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, +typedef enum +{ + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING = 0x00, + EMBER_ZCL_METERING_DEVICE_TYPE_GAS_METERING = 0x01, + EMBER_ZCL_METERING_DEVICE_TYPE_WATER_METERING = 0x02, + EMBER_ZCL_METERING_DEVICE_TYPE_THERMAL_METERING = 0x03, + EMBER_ZCL_METERING_DEVICE_TYPE_PRESSURE_METERING = 0x04, + EMBER_ZCL_METERING_DEVICE_TYPE_HEAT_METERING = 0x05, + EMBER_ZCL_METERING_DEVICE_TYPE_COOLING_METERING = 0x06, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_VEHICLE_CHARGING_METERING = 0x07, + EMBER_ZCL_METERING_DEVICE_TYPE_PV_GENERATION_METERING = 0x08, + EMBER_ZCL_METERING_DEVICE_TYPE_WIND_TURBINE_GENERATION_METERING = 0x09, + EMBER_ZCL_METERING_DEVICE_TYPE_WATER_TURBINE_GENERATION_METERING = 0x0A, + EMBER_ZCL_METERING_DEVICE_TYPE_MICRO_GENERATION_METERING = 0x0B, + EMBER_ZCL_METERING_DEVICE_TYPE_SOLAR_HOT_WATER_GENERATION_METERING = 0x0C, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT1 = 0x0D, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT2 = 0x0E, + EMBER_ZCL_METERING_DEVICE_TYPE_ELECTRIC_METERING_ELEMENT3 = 0x0F, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING = 0x7F, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_GAS_METERING = 0x80, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_METERING = 0x81, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_THERMAL_METERING = 0x82, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PRESSURE_METERING = 0x83, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_HEAT_METERING = 0x84, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_COOLING_METERING = 0x85, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_VEHICLE_CHARGING_METERING = 0x86, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_PV_GENERATION_METERING = 0x87, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WIND_TURBINE_GENERATION_METERING = 0x88, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_WATER_TURBINE_GENERATION_METERING = 0x89, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_MICRO_GENERATION_METERING = 0x8A, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_SOLAR_HOT_WATER_GENERATION_METERING = 0x8B, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT1 = 0x8C, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT2 = 0x8D, + EMBER_ZCL_METERING_DEVICE_TYPE_MIRRORED_ELECTRIC_METERING_ELEMENT3 = 0x8E, + EMBER_ZCL_METERING_DEVICE_TYPE_UNDEFINED_MIRROR_METER = 0xFE, } EmberAfMeteringDeviceType; -typedef enum { - EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF = 0x00, - EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, - EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_ON = 0x02, +typedef enum +{ + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF = 0x00, + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_METERING_SUPPLY_STATUS_SUPPLY_ON = 0x02, } EmberAfMeteringSupplyStatus; -typedef enum { - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN = 0x00, - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS = 0x01, - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT = 0x02, - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN_BCD = 0x80, - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS_BCD = 0x81, - EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT_BCD = 0x82, +typedef enum +{ + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN = 0x00, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS = 0x01, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT = 0x02, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_KELVIN_BCD = 0x80, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_CELSIUS_BCD = 0x81, + EMBER_ZCL_METERING_TEMPERATURE_UNIT_OF_MEASURE_FAHRENHEIT_BCD = 0x82, } EmberAfMeteringTemperatureUnitOfMeasure; -typedef enum { - EMBER_ZCL_MOVE_MODE_UP = 0x00, - EMBER_ZCL_MOVE_MODE_DOWN = 0x01, +typedef enum +{ + EMBER_ZCL_MOVE_MODE_UP = 0x00, + EMBER_ZCL_MOVE_MODE_DOWN = 0x01, } EmberAfMoveMode; -typedef enum { - EMBER_ZCL_NOTIFICATION_SCHEME_NO_NOTIFICATION_SCHEME_DEFINED = 0x00, - EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_A = 0x01, - EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_B = 0x02, +typedef enum +{ + EMBER_ZCL_NOTIFICATION_SCHEME_NO_NOTIFICATION_SCHEME_DEFINED = 0x00, + EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_A = 0x01, + EMBER_ZCL_NOTIFICATION_SCHEME_PREDEFINED_NOTIFICATION_SCHEME_B = 0x02, } EmberAfNotificationScheme; -typedef enum { - EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR = 0x00, - EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_ULTRASONIC = 0x01, - EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR_AND_ULTRASONIC = 0x02, - EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PHYSICAL_CONTACT = 0x03, +typedef enum +{ + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR = 0x00, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_ULTRASONIC = 0x01, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PIR_AND_ULTRASONIC = 0x02, + EMBER_ZCL_OCCUPANCY_SENSOR_TYPE_PHYSICAL_CONTACT = 0x03, } EmberAfOccupancySensorType; -typedef enum { - EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS = 0x00, - EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE = 0x01, - EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS = 0x02, +typedef enum +{ + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS = 0x00, + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE = 0x01, + EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS = 0x02, } EmberAfOnOffDelayedAllOffEffectVariant; -typedef enum { - EMBER_ZCL_ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND = 0x00, +typedef enum +{ + EMBER_ZCL_ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND = 0x00, } EmberAfOnOffDyingLightEffectVariant; -typedef enum { - EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF = 0x00, - EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT = 0x01, +typedef enum +{ + EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF = 0x00, + EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT = 0x01, } EmberAfOnOffEffectIdentifier; -typedef enum { - EMBER_ZCL_OPERATING_MODE_NORMAL = 0x00, - EMBER_ZCL_OPERATING_MODE_CONFIGURE = 0x01, +typedef enum +{ + EMBER_ZCL_OPERATING_MODE_NORMAL = 0x00, + EMBER_ZCL_OPERATING_MODE_CONFIGURE = 0x01, } EmberAfOperatingMode; -typedef enum { - EMBER_ZCL_ORIGINATING_DEVICE_ENERGY_SERVICE_INTERFACE = 0x00, - EMBER_ZCL_ORIGINATING_DEVICE_METER = 0x01, - EMBER_ZCL_ORIGINATING_DEVICE_IN_HOME_DISPLAY_DEVICE = 0x02, +typedef enum +{ + EMBER_ZCL_ORIGINATING_DEVICE_ENERGY_SERVICE_INTERFACE = 0x00, + EMBER_ZCL_ORIGINATING_DEVICE_METER = 0x01, + EMBER_ZCL_ORIGINATING_DEVICE_IN_HOME_DISPLAY_DEVICE = 0x02, } EmberAfOriginatingDevice; -typedef enum { - EMBER_ZCL_PASSWORD_TYPE_PASSWORD1_SERVICE_MENU_ACCESS = 0x01, - EMBER_ZCL_PASSWORD_TYPE_PASSWORD2_CONSUMER_MENU_ACCESS = 0x02, - EMBER_ZCL_PASSWORD_TYPE_PASSWORD3 = 0x03, - EMBER_ZCL_PASSWORD_TYPE_PASSWORD4 = 0x04, +typedef enum +{ + EMBER_ZCL_PASSWORD_TYPE_PASSWORD1_SERVICE_MENU_ACCESS = 0x01, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD2_CONSUMER_MENU_ACCESS = 0x02, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD3 = 0x03, + EMBER_ZCL_PASSWORD_TYPE_PASSWORD4 = 0x04, } EmberAfPasswordType; -typedef enum { - EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_BILLING_PERIOD = 0x00, - EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_CONSOLIDATED_BILL = 0x01, - EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_MONTH = 0x02, - EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_QUARTER = 0x03, - EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_YEAR = 0x04, +typedef enum +{ + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_BILLING_PERIOD = 0x00, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_CURRENT_CONSOLIDATED_BILL = 0x01, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_MONTH = 0x02, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_QUARTER = 0x03, + EMBER_ZCL_PAYMENT_DISCOUNT_DURATION_ONE_YEAR = 0x04, } EmberAfPaymentDiscountDuration; -typedef enum { - EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNSPECIFIED = 0x00, - EMBER_ZCL_PHYSICAL_ENVIRONMENT_FIRST_PROFILE_SPECIFIED_VALUE = 0x01, - EMBER_ZCL_PHYSICAL_ENVIRONMENT_LAST_PROFILE_SPECIFIED_VALUE = 0x7F, - EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNKNOWN = 0xFF, +typedef enum +{ + EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNSPECIFIED = 0x00, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_FIRST_PROFILE_SPECIFIED_VALUE = 0x01, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_LAST_PROFILE_SPECIFIED_VALUE = 0x7F, + EMBER_ZCL_PHYSICAL_ENVIRONMENT_UNKNOWN = 0xFF, } EmberAfPhysicalEnvironment; -typedef enum { - EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_WAITING_TO_START = 0x01, - EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_STARTED = 0x02, - EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_RUNNING = 0x03, - EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_ENDED = 0x04, - EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_WAITING_TO_START = 0x05, - EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_STARTED = 0x06, - EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_ENDED = 0x07, - EMBER_ZCL_POWER_PROFILE_STATE_PROFILE_READY_FOR_SCHEDULING = 0x08, - EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_SCHEDULED = 0x09, +typedef enum +{ + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_WAITING_TO_START = 0x01, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_STARTED = 0x02, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_RUNNING = 0x03, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_ENDED = 0x04, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_WAITING_TO_START = 0x05, + EMBER_ZCL_POWER_PROFILE_STATE_ENERGY_PHASE_STARTED = 0x06, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_ENDED = 0x07, + EMBER_ZCL_POWER_PROFILE_STATE_PROFILE_READY_FOR_SCHEDULING = 0x08, + EMBER_ZCL_POWER_PROFILE_STATE_POWER_PROFILE_SCHEDULED = 0x09, } EmberAfPowerProfileState; -typedef enum { - EMBER_ZCL_POWER_SOURCE_UNKNOWN = 0x00, - EMBER_ZCL_POWER_SOURCE_SINGLE_PHASE_MAINS = 0x01, - EMBER_ZCL_POWER_SOURCE_THREE_PHASE_MAINS = 0x02, - EMBER_ZCL_POWER_SOURCE_BATTERY = 0x03, - EMBER_ZCL_POWER_SOURCE_DC_SOURCE = 0x04, - EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_CONSTANT_POWER = 0x05, - EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_TRANSFER_SWITCH = 0x06, - EMBER_ZCL_POWER_SOURCE_BATTERY_BACKUP = 0x80, +typedef enum +{ + EMBER_ZCL_POWER_SOURCE_UNKNOWN = 0x00, + EMBER_ZCL_POWER_SOURCE_SINGLE_PHASE_MAINS = 0x01, + EMBER_ZCL_POWER_SOURCE_THREE_PHASE_MAINS = 0x02, + EMBER_ZCL_POWER_SOURCE_BATTERY = 0x03, + EMBER_ZCL_POWER_SOURCE_DC_SOURCE = 0x04, + EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_CONSTANT_POWER = 0x05, + EMBER_ZCL_POWER_SOURCE_EMERGENCY_MAINS_TRANSFER_SWITCH = 0x06, + EMBER_ZCL_POWER_SOURCE_BATTERY_BACKUP = 0x80, } EmberAfPowerSource; -typedef enum { - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_LOW_CREDIT = 0x00, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_NO_CREDIT = 0x01, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_CREDIT_EXHAUSTED = 0x02, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_ENABLED = 0x03, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_EXHAUSTED = 0x04, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_IHD_LOW_CREDIT_WARNING = 0x05, - EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EVENT_LOG_CLEARED = 0x06, +typedef enum +{ + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_LOW_CREDIT = 0x00, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_NO_CREDIT = 0x01, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_CREDIT_EXHAUSTED = 0x02, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_ENABLED = 0x03, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EMERGENCY_CREDIT_EXHAUSTED = 0x04, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_IHD_LOW_CREDIT_WARNING = 0x05, + EMBER_ZCL_PRE_PAY_GENERIC_ALARM_GROUP_EVENT_LOG_CLEARED = 0x06, } EmberAfPrePayGenericAlarmGroup; -typedef enum { - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PHYSICAL_ATTACK_ON_THE_PREPAY_METER = 0x20, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER = 0x21, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DISCOUNT_APPLIED = 0x22, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT = 0x23, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT_FAIL = 0x24, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT = 0x25, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT_FAIL = 0x26, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CHANGE = 0x27, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_ERROR = 0x28, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_ALREADY_USED = 0x29, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_INVALID = 0x2A, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_IN_USE = 0x2B, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END_WARNING = 0x2C, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END = 0x2D, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ERROR_REG_CLEAR = 0x30, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ALARM_REG_CLEAR = 0x31, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PREPAY_CLUSTER_NOT_FOUND = 0x32, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CREDIT2_PREPAY = 0x41, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_PREPAY2_CREDIT = 0x42, - EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_DEFAULT = 0x43, +typedef enum +{ + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PHYSICAL_ATTACK_ON_THE_PREPAY_METER = 0x20, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ELECTRONIC_ATTACK_ON_THE_PREPAY_METER = 0x21, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DISCOUNT_APPLIED = 0x22, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT = 0x23, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_CREDIT_ADJUSTMENT_FAIL = 0x24, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT = 0x25, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_DEBT_ADJUSTMENT_FAIL = 0x26, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CHANGE = 0x27, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_ERROR = 0x28, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_ALREADY_USED = 0x29, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_TOPUP_CODE_INVALID = 0x2A, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_IN_USE = 0x2B, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END_WARNING = 0x2C, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_FRIENDLY_CREDIT_PERIOD_END = 0x2D, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ERROR_REG_CLEAR = 0x30, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_ALARM_REG_CLEAR = 0x31, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_PREPAY_CLUSTER_NOT_FOUND = 0x32, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_CREDIT2_PREPAY = 0x41, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_PREPAY2_CREDIT = 0x42, + EMBER_ZCL_PREPAY_EVENT_ALARM_GROUP_MODE_DEFAULT = 0x43, } EmberAfPrepayEventAlarmGroup; -typedef enum { - EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_DEBT_CREDIT_STATUS = 0x00, - EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_NOT_USED = 0xFF, +typedef enum +{ + EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_DEBT_CREDIT_STATUS = 0x00, + EMBER_ZCL_PREPAY_SNAPSHOT_PAYLOAD_TYPE_NOT_USED = 0xFF, } EmberAfPrepaySnapshotPayloadType; -typedef enum { - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ON = 0x10, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ARM = 0x11, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_OFF = 0x12, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTION_FAILURE = 0x13, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_TAMPER_DETECTED = 0x14, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_CUT_OFF_VALUE = 0x15, - EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_REMOTE_DISCONNECTED = 0x16, +typedef enum +{ + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ON = 0x10, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_ARM = 0x11, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_SUPPLY_OFF = 0x12, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTION_FAILURE = 0x13, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_TAMPER_DETECTED = 0x14, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_DISCONNECTED_DUE_TO_CUT_OFF_VALUE = 0x15, + EMBER_ZCL_PREPAY_SWITCH_ALARM_GROUP_REMOTE_DISCONNECTED = 0x16, } EmberAfPrepaySwitchAlarmGroup; -typedef enum { - EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_NOT_REQUIRED = 0x00, - EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_REQUIRED = 0x01, +typedef enum +{ + EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_NOT_REQUIRED = 0x00, + EMBER_ZCL_PRICE_CONTROL_ACKNOWLEDGEMENT_REQUIRED = 0x01, } EmberAfPriceControlAcknowledgement; -typedef enum { - EMBER_ZCL_PRICE_TIER_NO_TIER_RELATED = 0x00, - EMBER_ZCL_PRICE_TIER_TIER1_PRICE_LABEL = 0x01, - EMBER_ZCL_PRICE_TIER_TIER2_PRICE_LABEL = 0x02, - EMBER_ZCL_PRICE_TIER_TIER3_PRICE_LABEL = 0x03, - EMBER_ZCL_PRICE_TIER_TIER4_PRICE_LABEL = 0x04, - EMBER_ZCL_PRICE_TIER_TIER5_PRICE_LABEL = 0x05, - EMBER_ZCL_PRICE_TIER_TIER6_PRICE_LABEL = 0x06, - EMBER_ZCL_PRICE_TIER_TIER7_PRICE_LABEL = 0x07, - EMBER_ZCL_PRICE_TIER_TIER8_PRICE_LABEL = 0x08, - EMBER_ZCL_PRICE_TIER_TIER9_PRICE_LABEL = 0x09, - EMBER_ZCL_PRICE_TIER_TIER10_PRICE_LABEL = 0x0A, - EMBER_ZCL_PRICE_TIER_TIER11_PRICE_LABEL = 0x0B, - EMBER_ZCL_PRICE_TIER_TIER12_PRICE_LABEL = 0x0C, - EMBER_ZCL_PRICE_TIER_TIER13_PRICE_LABEL = 0x0D, - EMBER_ZCL_PRICE_TIER_TIER14_PRICE_LABEL = 0x0E, - EMBER_ZCL_PRICE_TIER_TIER15_PRICE_LABEL = 0x0F, +typedef enum +{ + EMBER_ZCL_PRICE_TIER_NO_TIER_RELATED = 0x00, + EMBER_ZCL_PRICE_TIER_TIER1_PRICE_LABEL = 0x01, + EMBER_ZCL_PRICE_TIER_TIER2_PRICE_LABEL = 0x02, + EMBER_ZCL_PRICE_TIER_TIER3_PRICE_LABEL = 0x03, + EMBER_ZCL_PRICE_TIER_TIER4_PRICE_LABEL = 0x04, + EMBER_ZCL_PRICE_TIER_TIER5_PRICE_LABEL = 0x05, + EMBER_ZCL_PRICE_TIER_TIER6_PRICE_LABEL = 0x06, + EMBER_ZCL_PRICE_TIER_TIER7_PRICE_LABEL = 0x07, + EMBER_ZCL_PRICE_TIER_TIER8_PRICE_LABEL = 0x08, + EMBER_ZCL_PRICE_TIER_TIER9_PRICE_LABEL = 0x09, + EMBER_ZCL_PRICE_TIER_TIER10_PRICE_LABEL = 0x0A, + EMBER_ZCL_PRICE_TIER_TIER11_PRICE_LABEL = 0x0B, + EMBER_ZCL_PRICE_TIER_TIER12_PRICE_LABEL = 0x0C, + EMBER_ZCL_PRICE_TIER_TIER13_PRICE_LABEL = 0x0D, + EMBER_ZCL_PRICE_TIER_TIER14_PRICE_LABEL = 0x0E, + EMBER_ZCL_PRICE_TIER_TIER15_PRICE_LABEL = 0x0F, } EmberAfPriceTier; -typedef enum { - EMBER_ZCL_PRODUCT_CODE_MANUFACTURER_DEFINED = 0x00, - EMBER_ZCL_PRODUCT_CODE_ITERNATIONAL_ARTICLE_NUMBER = 0x01, - EMBER_ZCL_PRODUCT_CODE_GLOBAL_TRADE_ITEM_NUMBER = 0x02, - EMBER_ZCL_PRODUCT_CODE_UNIVERSAL_PRODUCT_CODE = 0x03, - EMBER_ZCL_PRODUCT_CODE_STOCK_KEEPING_UNIT = 0x04, +typedef enum +{ + EMBER_ZCL_PRODUCT_CODE_MANUFACTURER_DEFINED = 0x00, + EMBER_ZCL_PRODUCT_CODE_ITERNATIONAL_ARTICLE_NUMBER = 0x01, + EMBER_ZCL_PRODUCT_CODE_GLOBAL_TRADE_ITEM_NUMBER = 0x02, + EMBER_ZCL_PRODUCT_CODE_UNIVERSAL_PRODUCT_CODE = 0x03, + EMBER_ZCL_PRODUCT_CODE_STOCK_KEEPING_UNIT = 0x04, } EmberAfProductCode; -typedef enum { - EMBER_ZCL_PRODUCT_TYPE_ID_WHITE_GOODS = 0x0000, - EMBER_ZCL_PRODUCT_TYPE_ID_DISHWASHER = 0x5601, - EMBER_ZCL_PRODUCT_TYPE_ID_TUMBLE_DRYER = 0x5602, - EMBER_ZCL_PRODUCT_TYPE_ID_WASHER_DRYER = 0x5603, - EMBER_ZCL_PRODUCT_TYPE_ID_WASHING_MACHINE = 0x5604, - EMBER_ZCL_PRODUCT_TYPE_ID_HOBS = 0x5E03, - EMBER_ZCL_PRODUCT_TYPE_ID_INDUCTION_HOBS = 0x5E09, - EMBER_ZCL_PRODUCT_TYPE_ID_OVEN = 0x5E01, - EMBER_ZCL_PRODUCT_TYPE_ID_ELECTRICAL_OVEN = 0x5E06, - EMBER_ZCL_PRODUCT_TYPE_ID_REFRIGERATOR_FREEZER = 0x6601, +typedef enum +{ + EMBER_ZCL_PRODUCT_TYPE_ID_WHITE_GOODS = 0x0000, + EMBER_ZCL_PRODUCT_TYPE_ID_DISHWASHER = 0x5601, + EMBER_ZCL_PRODUCT_TYPE_ID_TUMBLE_DRYER = 0x5602, + EMBER_ZCL_PRODUCT_TYPE_ID_WASHER_DRYER = 0x5603, + EMBER_ZCL_PRODUCT_TYPE_ID_WASHING_MACHINE = 0x5604, + EMBER_ZCL_PRODUCT_TYPE_ID_HOBS = 0x5E03, + EMBER_ZCL_PRODUCT_TYPE_ID_INDUCTION_HOBS = 0x5E09, + EMBER_ZCL_PRODUCT_TYPE_ID_OVEN = 0x5E01, + EMBER_ZCL_PRODUCT_TYPE_ID_ELECTRICAL_OVEN = 0x5E06, + EMBER_ZCL_PRODUCT_TYPE_ID_REFRIGERATOR_FREEZER = 0x6601, } EmberAfProductTypeId; -typedef enum { - EMBER_ZCL_PROPOSED_SUPPLY_STATUS_RESERVED = 0x00, - EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, - EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_ON = 0x02, +typedef enum +{ + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_RESERVED = 0x00, + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_PROPOSED_SUPPLY_STATUS_SUPPLY_ON = 0x02, } EmberAfProposedSupplyStatus; -typedef enum { - EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_PENDING = 0x00, - EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_ACCEPTED = 0x01, - EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_REJECTED = 0x02, - EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_FORCED = 0x03, +typedef enum +{ + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_PENDING = 0x00, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_ACCEPTED = 0x01, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_REJECTED = 0x02, + EMBER_ZCL_PUBLISH_CPP_EVENT_CPP_AUTH_FORCED = 0x03, } EmberAfPublishCppEventCppAuth; -typedef enum { - EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_SPEED = 0x00, - EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_PRESSURE = 0x01, - EMBER_ZCL_PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02, - EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_FLOW = 0x03, - EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE = 0x05, - EMBER_ZCL_PUMP_CONTROL_MODE_AUTOMATIC = 0x07, +typedef enum +{ + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_SPEED = 0x00, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_PRESSURE = 0x01, + EMBER_ZCL_PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_FLOW = 0x03, + EMBER_ZCL_PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE = 0x05, + EMBER_ZCL_PUMP_CONTROL_MODE_AUTOMATIC = 0x07, } EmberAfPumpControlMode; -typedef enum { - EMBER_ZCL_PUMP_OPERATION_MODE_NORMAL = 0x00, - EMBER_ZCL_PUMP_OPERATION_MODE_MINIMUM = 0x01, - EMBER_ZCL_PUMP_OPERATION_MODE_MAXIMUM = 0x02, - EMBER_ZCL_PUMP_OPERATION_MODE_LOCAL = 0x03, +typedef enum +{ + EMBER_ZCL_PUMP_OPERATION_MODE_NORMAL = 0x00, + EMBER_ZCL_PUMP_OPERATION_MODE_MINIMUM = 0x01, + EMBER_ZCL_PUMP_OPERATION_MODE_MAXIMUM = 0x02, + EMBER_ZCL_PUMP_OPERATION_MODE_LOCAL = 0x03, } EmberAfPumpOperationMode; -typedef enum { - EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_DAY = 0x0040, - EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_WEEK = 0x0080, - EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_MONTH = 0x0180, - EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_YEAR = 0x01C0, +typedef enum +{ + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_DAY = 0x0040, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_WEEK = 0x0080, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_MONTH = 0x0180, + EMBER_ZCL_PUSH_HISTORICAL_METERING_DATA_YEAR = 0x01C0, } EmberAfPushHistoricalMeteringData; -typedef enum { - EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_DAY = 0x0200, - EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_WEEK = 0x0400, - EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_MONTH = 0x0C00, - EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_YEAR = 0x0E00, +typedef enum +{ + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_DAY = 0x0200, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_WEEK = 0x0400, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_MONTH = 0x0C00, + EMBER_ZCL_PUSH_HISTORICAL_PAYMENT_DATA_YEAR = 0x0E00, } EmberAfPushHistoricalPaymentData; -typedef enum { - EMBER_ZCL_REGISTER_TIER_NO_TIER_RELATED = 0x00, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, - EMBER_ZCL_REGISTER_TIER_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, +typedef enum +{ + EMBER_ZCL_REGISTER_TIER_NO_TIER_RELATED = 0x00, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER1_SUMMATION_DELIVERED_ATTRIBUTE = 0x01, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER2_SUMMATION_DELIVERED_ATTRIBUTE = 0x02, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER3_SUMMATION_DELIVERED_ATTRIBUTE = 0x03, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER4_SUMMATION_DELIVERED_ATTRIBUTE = 0x04, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER5_SUMMATION_DELIVERED_ATTRIBUTE = 0x05, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER6_SUMMATION_DELIVERED_ATTRIBUTE = 0x06, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER7_SUMMATION_DELIVERED_ATTRIBUTE = 0x07, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER8_SUMMATION_DELIVERED_ATTRIBUTE = 0x08, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER9_SUMMATION_DELIVERED_ATTRIBUTE = 0x09, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER10_SUMMATION_DELIVERED_ATTRIBUTE = 0x0A, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER11_SUMMATION_DELIVERED_ATTRIBUTE = 0x0B, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER12_SUMMATION_DELIVERED_ATTRIBUTE = 0x0C, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER13_SUMMATION_DELIVERED_ATTRIBUTE = 0x0D, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER14_SUMMATION_DELIVERED_ATTRIBUTE = 0x0E, + EMBER_ZCL_REGISTER_TIER_CURRENT_TIER15_SUMMATION_DELIVERED_ATTRIBUTE = 0x0F, } EmberAfRegisterTier; -typedef enum { - EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_NOT_DISPLAYED = 0x00, - EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_DISPLAYED = 0x01, +typedef enum +{ + EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_NOT_DISPLAYED = 0x00, + EMBER_ZCL_RELATIVE_HUMIDITY_DISPLAY_DISPLAYED = 0x01, } EmberAfRelativeHumidityDisplay; -typedef enum { - EMBER_ZCL_RELATIVE_HUMIDITY_MODE_MEASURE_LOCALLY = 0x00, - EMBER_ZCL_RELATIVE_HUMIDITY_MODE_UPDATED_OVER_THE_NETWORK = 0x01, +typedef enum +{ + EMBER_ZCL_RELATIVE_HUMIDITY_MODE_MEASURE_LOCALLY = 0x00, + EMBER_ZCL_RELATIVE_HUMIDITY_MODE_UPDATED_OVER_THE_NETWORK = 0x01, } EmberAfRelativeHumidityMode; -typedef enum { - EMBER_ZCL_REMOTE_ENABLE_FLAGS_DISABLED = 0x00, - EMBER_ZCL_REMOTE_ENABLE_FLAGS_TEMPORARILY_LOCKED_DISABLED = 0x07, - EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_CONTROL = 0x0F, - EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_AND_ENERGY_CONTROL = 0x01, +typedef enum +{ + EMBER_ZCL_REMOTE_ENABLE_FLAGS_DISABLED = 0x00, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_TEMPORARILY_LOCKED_DISABLED = 0x07, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_CONTROL = 0x0F, + EMBER_ZCL_REMOTE_ENABLE_FLAGS_ENABLED_REMOTE_AND_ENERGY_CONTROL = 0x01, } EmberAfRemoteEnableFlags; -typedef enum { - EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT1 = 0x00, - EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT2 = 0x01, - EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT3 = 0x02, - EMBER_ZCL_REPAYMENT_DEBT_TYPE_ALL_DEBTS = 0xFF, +typedef enum +{ + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT1 = 0x00, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT2 = 0x01, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_DEBT3 = 0x02, + EMBER_ZCL_REPAYMENT_DEBT_TYPE_ALL_DEBTS = 0xFF, } EmberAfRepaymentDebtType; -typedef enum { - EMBER_ZCL_REPORTING_DIRECTION_REPORTED = 0x00, - EMBER_ZCL_REPORTING_DIRECTION_RECEIVED = 0x01, +typedef enum +{ + EMBER_ZCL_REPORTING_DIRECTION_REPORTED = 0x00, + EMBER_ZCL_REPORTING_DIRECTION_RECEIVED = 0x01, } EmberAfReportingDirection; -typedef enum { - EMBER_ZCL_RESULT_TYPE_ACCEPTED = 0x00, - EMBER_ZCL_RESULT_TYPE_REJECTED_INVALID_TOP_UP = 0x01, - EMBER_ZCL_RESULT_TYPE_REJECTED_DUPLICATE_TOP_UP = 0x02, - EMBER_ZCL_RESULT_TYPE_REJECTED_ERROR = 0x03, - EMBER_ZCL_RESULT_TYPE_REJECTED_MAX_CREDIT_REACHED = 0x04, - EMBER_ZCL_RESULT_TYPE_REJECTED_KEYPAD_LOCK = 0x05, - EMBER_ZCL_RESULT_TYPE_REJECTED_TOP_UP_VALUE_TOO_LARGE = 0x06, - EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ENABLED = 0x10, - EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_DISABLED = 0x11, - EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ARMED = 0x12, +typedef enum +{ + EMBER_ZCL_RESULT_TYPE_ACCEPTED = 0x00, + EMBER_ZCL_RESULT_TYPE_REJECTED_INVALID_TOP_UP = 0x01, + EMBER_ZCL_RESULT_TYPE_REJECTED_DUPLICATE_TOP_UP = 0x02, + EMBER_ZCL_RESULT_TYPE_REJECTED_ERROR = 0x03, + EMBER_ZCL_RESULT_TYPE_REJECTED_MAX_CREDIT_REACHED = 0x04, + EMBER_ZCL_RESULT_TYPE_REJECTED_KEYPAD_LOCK = 0x05, + EMBER_ZCL_RESULT_TYPE_REJECTED_TOP_UP_VALUE_TOO_LARGE = 0x06, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ENABLED = 0x10, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_DISABLED = 0x11, + EMBER_ZCL_RESULT_TYPE_ACCEPTED_SUPPLY_ARMED = 0x12, } EmberAfResultType; -typedef enum { - EMBER_ZCL_SAMPLE_TYPE_CONSUMPTION_DELIVERED = 0x00, +typedef enum +{ + EMBER_ZCL_SAMPLE_TYPE_CONSUMPTION_DELIVERED = 0x00, } EmberAfSampleType; -typedef enum { - EMBER_ZCL_SATURATION_MOVE_MODE_STOP = 0x00, - EMBER_ZCL_SATURATION_MOVE_MODE_UP = 0x01, - EMBER_ZCL_SATURATION_MOVE_MODE_DOWN = 0x03, +typedef enum +{ + EMBER_ZCL_SATURATION_MOVE_MODE_STOP = 0x00, + EMBER_ZCL_SATURATION_MOVE_MODE_UP = 0x01, + EMBER_ZCL_SATURATION_MOVE_MODE_DOWN = 0x03, } EmberAfSaturationMoveMode; -typedef enum { - EMBER_ZCL_SATURATION_STEP_MODE_UP = 0x01, - EMBER_ZCL_SATURATION_STEP_MODE_DOWN = 0x03, +typedef enum +{ + EMBER_ZCL_SATURATION_STEP_MODE_UP = 0x01, + EMBER_ZCL_SATURATION_STEP_MODE_DOWN = 0x03, } EmberAfSaturationStepMode; -typedef enum { - EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, - EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_CMOS = 0x01, +typedef enum +{ + EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_PHOTODIODE = 0x00, + EMBER_ZCL_SENSING_LIGHT_SENSOR_TYPE_CMOS = 0x01, } EmberAfSensingLightSensorType; -typedef enum { - EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_SETPOINT = 0x00, - EMBER_ZCL_SETPOINT_ADJUST_MODE_COOL_SETPOINT = 0x01, - EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS = 0x02, +typedef enum +{ + EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_SETPOINT = 0x00, + EMBER_ZCL_SETPOINT_ADJUST_MODE_COOL_SETPOINT = 0x01, + EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS = 0x02, } EmberAfSetpointAdjustMode; -typedef enum { - EMBER_ZCL_SIGNATURE_TYPE_RESERVED = 0x00, - EMBER_ZCL_SIGNATURE_TYPE_ECDSA = 0x01, +typedef enum +{ + EMBER_ZCL_SIGNATURE_TYPE_RESERVED = 0x00, + EMBER_ZCL_SIGNATURE_TYPE_ECDSA = 0x01, } EmberAfSignatureType; -typedef enum { - EMBER_ZCL_SNAPSHOT_CONFIRMATION_ACCEPTED = 0x00, - EMBER_ZCL_SNAPSHOT_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x01, +typedef enum +{ + EMBER_ZCL_SNAPSHOT_CONFIRMATION_ACCEPTED = 0x00, + EMBER_ZCL_SNAPSHOT_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x01, } EmberAfSnapshotConfirmation; -typedef enum { - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS = 0x00, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTERS = 0x01, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED = 0x02, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED = 0x03, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS_NO_BILLING = 0x04, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTER_NO_BILLINGS = 0x05, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED_NO_BILLING = 0x06, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED_NO_BILLING = 0x07, - EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_DATA_UNAVAILABLE = 0x80, +typedef enum +{ + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS = 0x00, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTERS = 0x01, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED = 0x02, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED = 0x03, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_DELIVERED_REGISTERS_NO_BILLING = 0x04, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_TOU_INFORMATION_SET_RECEIVED_REGISTER_NO_BILLINGS = 0x05, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_DELIVERED_NO_BILLING = 0x06, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_BLOCK_TIER_INFORMATION_SET_RECEIVED_NO_BILLING = 0x07, + EMBER_ZCL_SNAPSHOT_PAYLOAD_TYPE_DATA_UNAVAILABLE = 0x80, } EmberAfSnapshotPayloadType; -typedef enum { - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_ACCEPTED = 0x00, - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_TYPE_NOT_SUPPORTED = 0x01, - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x02, - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULE_NOT_CURRENTLY_AVAILABLE = 0x03, - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULES_NOT_SUPPORTED_BY_DEVICE = 0x04, - EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_INSUFFICIENT_SPACE_FOR_SNAPSHOT_SCHEDULE = 0x05, +typedef enum +{ + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_ACCEPTED = 0x00, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_TYPE_NOT_SUPPORTED = 0x01, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_CAUSE_NOT_SUPPORTED = 0x02, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULE_NOT_CURRENTLY_AVAILABLE = 0x03, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_SNAPSHOT_SCHEDULES_NOT_SUPPORTED_BY_DEVICE = 0x04, + EMBER_ZCL_SNAPSHOT_SCHEDULE_CONFIRMATION_INSUFFICIENT_SPACE_FOR_SNAPSHOT_SCHEDULE = 0x05, } EmberAfSnapshotScheduleConfirmation; -typedef enum { - EMBER_ZCL_SQUAWK_LEVEL_LOW_LEVEL = 0x00, - EMBER_ZCL_SQUAWK_LEVEL_MEDIUM_LEVEL = 0x01, - EMBER_ZCL_SQUAWK_LEVEL_VERY_HIGH_LEVEL = 0x02, +typedef enum +{ + EMBER_ZCL_SQUAWK_LEVEL_LOW_LEVEL = 0x00, + EMBER_ZCL_SQUAWK_LEVEL_MEDIUM_LEVEL = 0x01, + EMBER_ZCL_SQUAWK_LEVEL_VERY_HIGH_LEVEL = 0x02, } EmberAfSquawkLevel; -typedef enum { - EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_ARMED = 0x00, - EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_DISARMED = 0x01, +typedef enum +{ + EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_ARMED = 0x00, + EMBER_ZCL_SQUAWK_MODE_SYSTEM_IS_DISARMED = 0x01, } EmberAfSquawkMode; -typedef enum { - EMBER_ZCL_SQUAWK_STOBE_NO_STROBE = 0x00, - EMBER_ZCL_SQUAWK_STOBE_USE_STROBE = 0x01, +typedef enum +{ + EMBER_ZCL_SQUAWK_STOBE_NO_STROBE = 0x00, + EMBER_ZCL_SQUAWK_STOBE_USE_STROBE = 0x01, } EmberAfSquawkStobe; -typedef enum { - EMBER_ZCL_START_OF_WEEK_SUNDAY = 0x00, - EMBER_ZCL_START_OF_WEEK_MONDAY = 0x01, - EMBER_ZCL_START_OF_WEEK_TUESDAY = 0x02, - EMBER_ZCL_START_OF_WEEK_WEDNESDAY = 0x03, - EMBER_ZCL_START_OF_WEEK_THURSDAY = 0x04, - EMBER_ZCL_START_OF_WEEK_FRIDAY = 0x05, - EMBER_ZCL_START_OF_WEEK_SATURDAY = 0x06, +typedef enum +{ + EMBER_ZCL_START_OF_WEEK_SUNDAY = 0x00, + EMBER_ZCL_START_OF_WEEK_MONDAY = 0x01, + EMBER_ZCL_START_OF_WEEK_TUESDAY = 0x02, + EMBER_ZCL_START_OF_WEEK_WEDNESDAY = 0x03, + EMBER_ZCL_START_OF_WEEK_THURSDAY = 0x04, + EMBER_ZCL_START_OF_WEEK_FRIDAY = 0x05, + EMBER_ZCL_START_OF_WEEK_SATURDAY = 0x06, } EmberAfStartOfWeek; -typedef enum { - EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF = 0x00, - EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON = 0x01, - EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE = 0x02, - EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS = 0xFF, +typedef enum +{ + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF = 0x00, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON = 0x01, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE = 0x02, + EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS = 0xFF, } EmberAfStartUpOnOffValue; -typedef enum { - EMBER_ZCL_STATUS_SUCCESS = 0x00, - EMBER_ZCL_STATUS_FAILURE = 0x01, - EMBER_ZCL_STATUS_REQUEST_DENIED = 0x70, - EMBER_ZCL_STATUS_MULTIPLE_REQUEST_NOT_ALLOWED = 0x71, - EMBER_ZCL_STATUS_INDICATION_REDIRECTION_TO_AP = 0x72, - EMBER_ZCL_STATUS_PREFERENCE_DENIED = 0x73, - EMBER_ZCL_STATUS_PREFERENCE_IGNORED = 0x74, - EMBER_ZCL_STATUS_NOT_AUTHORIZED = 0x7E, - EMBER_ZCL_STATUS_RESERVED_FIELD_NOT_ZERO = 0x7F, - EMBER_ZCL_STATUS_MALFORMED_COMMAND = 0x80, - EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND = 0x81, - EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND = 0x82, - EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND = 0x83, - EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND = 0x84, - EMBER_ZCL_STATUS_INVALID_FIELD = 0x85, - EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE = 0x86, - EMBER_ZCL_STATUS_INVALID_VALUE = 0x87, - EMBER_ZCL_STATUS_READ_ONLY = 0x88, - EMBER_ZCL_STATUS_INSUFFICIENT_SPACE = 0x89, - EMBER_ZCL_STATUS_DUPLICATE_EXISTS = 0x8A, - EMBER_ZCL_STATUS_NOT_FOUND = 0x8B, - EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE = 0x8C, - EMBER_ZCL_STATUS_INVALID_DATA_TYPE = 0x8D, - EMBER_ZCL_STATUS_INVALID_SELECTOR = 0x8E, - EMBER_ZCL_STATUS_WRITE_ONLY = 0x8F, - EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE = 0x90, - EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND = 0x91, - EMBER_ZCL_STATUS_INCONSISTENT = 0x92, - EMBER_ZCL_STATUS_ACTION_DENIED = 0x93, - EMBER_ZCL_STATUS_TIMEOUT = 0x94, - EMBER_ZCL_STATUS_ABORT = 0x95, - EMBER_ZCL_STATUS_INVALID_IMAGE = 0x96, - EMBER_ZCL_STATUS_WAIT_FOR_DATA = 0x97, - EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE = 0x98, - EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE = 0x99, - EMBER_ZCL_STATUS_HARDWARE_FAILURE = 0xC0, - EMBER_ZCL_STATUS_SOFTWARE_FAILURE = 0xC1, - EMBER_ZCL_STATUS_CALIBRATION_ERROR = 0xC2, - EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER = 0xC3, +typedef enum +{ + EMBER_ZCL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_STATUS_FAILURE = 0x01, + EMBER_ZCL_STATUS_REQUEST_DENIED = 0x70, + EMBER_ZCL_STATUS_MULTIPLE_REQUEST_NOT_ALLOWED = 0x71, + EMBER_ZCL_STATUS_INDICATION_REDIRECTION_TO_AP = 0x72, + EMBER_ZCL_STATUS_PREFERENCE_DENIED = 0x73, + EMBER_ZCL_STATUS_PREFERENCE_IGNORED = 0x74, + EMBER_ZCL_STATUS_NOT_AUTHORIZED = 0x7E, + EMBER_ZCL_STATUS_RESERVED_FIELD_NOT_ZERO = 0x7F, + EMBER_ZCL_STATUS_MALFORMED_COMMAND = 0x80, + EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND = 0x81, + EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND = 0x82, + EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND = 0x83, + EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND = 0x84, + EMBER_ZCL_STATUS_INVALID_FIELD = 0x85, + EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE = 0x86, + EMBER_ZCL_STATUS_INVALID_VALUE = 0x87, + EMBER_ZCL_STATUS_READ_ONLY = 0x88, + EMBER_ZCL_STATUS_INSUFFICIENT_SPACE = 0x89, + EMBER_ZCL_STATUS_DUPLICATE_EXISTS = 0x8A, + EMBER_ZCL_STATUS_NOT_FOUND = 0x8B, + EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE = 0x8C, + EMBER_ZCL_STATUS_INVALID_DATA_TYPE = 0x8D, + EMBER_ZCL_STATUS_INVALID_SELECTOR = 0x8E, + EMBER_ZCL_STATUS_WRITE_ONLY = 0x8F, + EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE = 0x90, + EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND = 0x91, + EMBER_ZCL_STATUS_INCONSISTENT = 0x92, + EMBER_ZCL_STATUS_ACTION_DENIED = 0x93, + EMBER_ZCL_STATUS_TIMEOUT = 0x94, + EMBER_ZCL_STATUS_ABORT = 0x95, + EMBER_ZCL_STATUS_INVALID_IMAGE = 0x96, + EMBER_ZCL_STATUS_WAIT_FOR_DATA = 0x97, + EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE = 0x98, + EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE = 0x99, + EMBER_ZCL_STATUS_HARDWARE_FAILURE = 0xC0, + EMBER_ZCL_STATUS_SOFTWARE_FAILURE = 0xC1, + EMBER_ZCL_STATUS_CALIBRATION_ERROR = 0xC2, + EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER = 0xC3, } EmberAfStatus; -typedef enum { - EMBER_ZCL_STEP_MODE_UP = 0x00, - EMBER_ZCL_STEP_MODE_DOWN = 0x01, +typedef enum +{ + EMBER_ZCL_STEP_MODE_UP = 0x00, + EMBER_ZCL_STEP_MODE_DOWN = 0x01, } EmberAfStepMode; -typedef enum { - EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF = 0x00, - EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, - EMBER_ZCL_SUPPLY_STATUS_SUPPLY_ON = 0x02, - EMBER_ZCL_SUPPLY_STATUS_SUPPLY_UNCHANGED = 0x03, +typedef enum +{ + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF = 0x00, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_OFF_ARMED = 0x01, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_ON = 0x02, + EMBER_ZCL_SUPPLY_STATUS_SUPPLY_UNCHANGED = 0x03, } EmberAfSupplyStatus; -typedef enum { - EMBER_ZCL_SWITCH_ACTIONS_ON = 0x00, - EMBER_ZCL_SWITCH_ACTIONS_OFF = 0x01, - EMBER_ZCL_SWITCH_ACTIONS_TOGGLE = 0x02, +typedef enum +{ + EMBER_ZCL_SWITCH_ACTIONS_ON = 0x00, + EMBER_ZCL_SWITCH_ACTIONS_OFF = 0x01, + EMBER_ZCL_SWITCH_ACTIONS_TOGGLE = 0x02, } EmberAfSwitchActions; -typedef enum { - EMBER_ZCL_SWITCH_TYPE_TOGGLE = 0x00, - EMBER_ZCL_SWITCH_TYPE_MOMENTARY = 0x01, - EMBER_ZCL_SWITCH_TYPE_MULTI_FUNCTION = 0x02, +typedef enum +{ + EMBER_ZCL_SWITCH_TYPE_TOGGLE = 0x00, + EMBER_ZCL_SWITCH_TYPE_MOMENTARY = 0x01, + EMBER_ZCL_SWITCH_TYPE_MULTI_FUNCTION = 0x02, } EmberAfSwitchType; -typedef enum { - EMBER_ZCL_TARIFF_CHARGING_SCHEME_TOU_TARIFF = 0x00, - EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TARIFF = 0x10, - EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_COMMON_THRESHOLDS = 0x20, - EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_INDIVIDUAL_THRESHOLDS_PER_TIER = 0x30, +typedef enum +{ + EMBER_ZCL_TARIFF_CHARGING_SCHEME_TOU_TARIFF = 0x00, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TARIFF = 0x10, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_COMMON_THRESHOLDS = 0x20, + EMBER_ZCL_TARIFF_CHARGING_SCHEME_BLOCK_TOU_TARIFF_WITH_INDIVIDUAL_THRESHOLDS_PER_TIER = 0x30, } EmberAfTariffChargingScheme; -typedef enum { - EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_NOT_DEFINED = 0x00, - EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_BLOCK_PERIOD = 0x01, - EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_ONE_DAY = 0x02, +typedef enum +{ + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_NOT_DEFINED = 0x00, + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_BLOCK_PERIOD = 0x01, + EMBER_ZCL_TARIFF_RESOLUTION_PERIOD_ONE_DAY = 0x02, } EmberAfTariffResolutionPeriod; -typedef enum { - EMBER_ZCL_TARIFF_TYPE_DELIVERED_TARIFF = 0x00, - EMBER_ZCL_TARIFF_TYPE_RECEIVED_TARIFF = 0x01, - EMBER_ZCL_TARIFF_TYPE_DELIVERED_AND_RECEIVED_TARIFF = 0x02, +typedef enum +{ + EMBER_ZCL_TARIFF_TYPE_DELIVERED_TARIFF = 0x00, + EMBER_ZCL_TARIFF_TYPE_RECEIVED_TARIFF = 0x01, + EMBER_ZCL_TARIFF_TYPE_DELIVERED_AND_RECEIVED_TARIFF = 0x02, } EmberAfTariffType; -typedef enum { - EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_CELSIUS = 0x00, - EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_FAHRENHEIT = 0x01, +typedef enum +{ + EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_CELSIUS = 0x00, + EMBER_ZCL_TEMPERATURE_DISPLAY_MODE_FAHRENHEIT = 0x01, } EmberAfTemperatureDisplayMode; -typedef enum { - EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_OFF = 0x00, - EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_ON = 0x01, +typedef enum +{ + EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_OFF = 0x00, + EMBER_ZCL_TEMPERATURE_SETPOINT_HOLD_SETPOINT_HOLD_ON = 0x01, } EmberAfTemperatureSetpointHold; -typedef enum { - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_ONLY = 0x00, - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_WITH_REHEAT = 0x01, - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_ONLY = 0x02, - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_WITH_REHEAT = 0x03, - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING = 0x04, - EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING_WITH_REHEAT = 0x05, +typedef enum +{ + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_ONLY = 0x00, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_WITH_REHEAT = 0x01, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_ONLY = 0x02, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_HEATING_WITH_REHEAT = 0x03, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING = 0x04, + EMBER_ZCL_THERMOSTAT_CONTROL_SEQUENCE_COOLING_AND_HEATING_WITH_REHEAT = 0x05, } EmberAfThermostatControlSequence; -typedef enum { - EMBER_ZCL_THERMOSTAT_RUNNING_MODE_OFF = 0x00, - EMBER_ZCL_THERMOSTAT_RUNNING_MODE_COOL = 0x03, - EMBER_ZCL_THERMOSTAT_RUNNING_MODE_HEAT = 0x04, +typedef enum +{ + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_OFF = 0x00, + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_COOL = 0x03, + EMBER_ZCL_THERMOSTAT_RUNNING_MODE_HEAT = 0x04, } EmberAfThermostatRunningMode; -typedef enum { - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_OFF = 0x00, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_AUTO = 0x01, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_COOL = 0x03, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_HEAT = 0x04, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_EMERGENCY_HEATING = 0x05, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_PRECOOLING = 0x06, - EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_FAN_ONLY = 0x07, +typedef enum +{ + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_OFF = 0x00, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_AUTO = 0x01, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_COOL = 0x03, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_HEAT = 0x04, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_EMERGENCY_HEATING = 0x05, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_PRECOOLING = 0x06, + EMBER_ZCL_THERMOSTAT_SYSTEM_MODE_FAN_ONLY = 0x07, } EmberAfThermostatSystemMode; -typedef enum { - EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK = 0x00, - EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER = 0x01, - EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER_THRESHOLD = 0x02, - EMBER_ZCL_TIER_BLOCK_MODE_NOT_USED = 0xFF, +typedef enum +{ + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK = 0x00, + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER = 0x01, + EMBER_ZCL_TIER_BLOCK_MODE_ACTIVE_BLOCK_PRICE_TIER_THRESHOLD = 0x02, + EMBER_ZCL_TIER_BLOCK_MODE_NOT_USED = 0xFF, } EmberAfTierBlockMode; -typedef enum { - EMBER_ZCL_TIME_ENCODING_RELATIVE = 0x00, - EMBER_ZCL_TIME_ENCODING_ABSOLUTE = 0x40, +typedef enum +{ + EMBER_ZCL_TIME_ENCODING_RELATIVE = 0x00, + EMBER_ZCL_TIME_ENCODING_ABSOLUTE = 0x40, } EmberAfTimeEncoding; -typedef enum { - EMBER_ZCL_TUNNELING_PROTOCOL_ID_DLMS_COSEM = 0x00, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_IEC_61107 = 0x01, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_ANSI_C12 = 0x02, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_M_BUS = 0x03, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_SML = 0x04, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_CLIMATE_TALK = 0x05, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_GB_HRGP = 0x06, - EMBER_ZCL_TUNNELING_PROTOCOL_ID_TEST = 0xC7, +typedef enum +{ + EMBER_ZCL_TUNNELING_PROTOCOL_ID_DLMS_COSEM = 0x00, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_IEC_61107 = 0x01, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_ANSI_C12 = 0x02, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_M_BUS = 0x03, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_SML = 0x04, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_CLIMATE_TALK = 0x05, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_GB_HRGP = 0x06, + EMBER_ZCL_TUNNELING_PROTOCOL_ID_TEST = 0xC7, } EmberAfTunnelingProtocolId; -typedef enum { - EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_NO_SUCH_TUNNEL = 0x00, - EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_WRONG_DEVICE = 0x01, - EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_DATA_OVERFLOW = 0x02, +typedef enum +{ + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_NO_SUCH_TUNNEL = 0x00, + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_WRONG_DEVICE = 0x01, + EMBER_ZCL_TUNNELING_TRANSFER_DATA_STATUS_DATA_OVERFLOW = 0x02, } EmberAfTunnelingTransferDataStatus; -typedef enum { - EMBER_ZCL_TUNNELING_TUNNEL_STATUS_SUCCESS = 0x00, - EMBER_ZCL_TUNNELING_TUNNEL_STATUS_BUSY = 0x01, - EMBER_ZCL_TUNNELING_TUNNEL_STATUS_NO_MORE_TUNNEL_IDS = 0x02, - EMBER_ZCL_TUNNELING_TUNNEL_STATUS_PROTOCOL_NOT_SUPPORTED = 0x03, - EMBER_ZCL_TUNNELING_TUNNEL_STATUS_FLOW_CONTROL_NOT_SUPPORTED = 0x04, +typedef enum +{ + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_BUSY = 0x01, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_NO_MORE_TUNNEL_IDS = 0x02, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_PROTOCOL_NOT_SUPPORTED = 0x03, + EMBER_ZCL_TUNNELING_TUNNEL_STATUS_FLOW_CONTROL_NOT_SUPPORTED = 0x04, } EmberAfTunnelingTunnelStatus; -typedef enum { - EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_NOT_AVAILABLE = 0x00, - EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_AVAILABLE = 0x01, +typedef enum +{ + EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_NOT_AVAILABLE = 0x00, + EMBER_ZCL_WAN_STATUS_CONNECTION_TO_WAN_IS_AVAILABLE = 0x01, } EmberAfWanStatus; -typedef enum { - EMBER_ZCL_WARNING_EVENT_WARNING1_OVERALL_POWER_ABOVE_AVAILABLE_POWER_LEVEL = 0x00, - EMBER_ZCL_WARNING_EVENT_WARNING2_OVERALL_POWER_ABOVE_POWER_THRESHOLD_LEVEL = 0x01, - EMBER_ZCL_WARNING_EVENT_WARNING3_OVERALL_POWER_BACK_BELOW_THE_AVAILABLE_POWER_LEVEL = 0x02, - EMBER_ZCL_WARNING_EVENT_WARNING4_OVERALL_POWER_BACK_BELOW_THE_POWER_THRESHOLD_LEVEL = 0x03, - EMBER_ZCL_WARNING_EVENT_WARNING5_OVERALL_POWER_WILL_BE_POTENTIALLY_ABOVE_AVAILABLE_POWER_LEVEL_IF_THE_APPLIANCE_STARTS = 0x04, +typedef enum +{ + EMBER_ZCL_WARNING_EVENT_WARNING1_OVERALL_POWER_ABOVE_AVAILABLE_POWER_LEVEL = 0x00, + EMBER_ZCL_WARNING_EVENT_WARNING2_OVERALL_POWER_ABOVE_POWER_THRESHOLD_LEVEL = 0x01, + EMBER_ZCL_WARNING_EVENT_WARNING3_OVERALL_POWER_BACK_BELOW_THE_AVAILABLE_POWER_LEVEL = 0x02, + EMBER_ZCL_WARNING_EVENT_WARNING4_OVERALL_POWER_BACK_BELOW_THE_POWER_THRESHOLD_LEVEL = 0x03, + EMBER_ZCL_WARNING_EVENT_WARNING5_OVERALL_POWER_WILL_BE_POTENTIALLY_ABOVE_AVAILABLE_POWER_LEVEL_IF_THE_APPLIANCE_STARTS = 0x04, } EmberAfWarningEvent; -typedef enum { - EMBER_ZCL_WARNING_MODE_STOP = 0x00, - EMBER_ZCL_WARNING_MODE_BURGLAR = 0x01, - EMBER_ZCL_WARNING_MODE_FIRE = 0x02, - EMBER_ZCL_WARNING_MODE_EMERGENCY = 0x03, - EMBER_ZCL_WARNING_MODE_POLICE_PANIC = 0x04, - EMBER_ZCL_WARNING_MODE_FIRE_PANIC = 0x05, - EMBER_ZCL_WARNING_MODE_EMERGENCY_PANIC = 0x06, +typedef enum +{ + EMBER_ZCL_WARNING_MODE_STOP = 0x00, + EMBER_ZCL_WARNING_MODE_BURGLAR = 0x01, + EMBER_ZCL_WARNING_MODE_FIRE = 0x02, + EMBER_ZCL_WARNING_MODE_EMERGENCY = 0x03, + EMBER_ZCL_WARNING_MODE_POLICE_PANIC = 0x04, + EMBER_ZCL_WARNING_MODE_FIRE_PANIC = 0x05, + EMBER_ZCL_WARNING_MODE_EMERGENCY_PANIC = 0x06, } EmberAfWarningMode; -typedef enum { - EMBER_ZCL_WARNING_STOBE_NO_STROBE = 0x00, - EMBER_ZCL_WARNING_STOBE_USE_STROBE = 0x01, +typedef enum +{ + EMBER_ZCL_WARNING_STOBE_NO_STROBE = 0x00, + EMBER_ZCL_WARNING_STOBE_USE_STROBE = 0x01, } EmberAfWarningStobe; -typedef enum { - EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_TRIP_TO_PAIR = 0x00, - EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_AUTO_ENROLLMENT_RESPONSE = 0x01, - EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_REQUEST = 0x02, +typedef enum +{ + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_TRIP_TO_PAIR = 0x00, + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_AUTO_ENROLLMENT_RESPONSE = 0x01, + EMBER_ZCL_WWAH_IAS_ZONE_ENROLLMENT_MODE_REQUEST = 0x02, } EmberAfWwahIasZoneEnrollmentMode; -typedef enum { - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_UNKNOWN = 0x00, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BATTERY = 0x01, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BROWNOUT = 0x02, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_WATCHDOG = 0x03, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_RESET_PIN = 0x04, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_MEMORY_HARDWARE_FAULT = 0x05, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFWARE_EXCEPTION = 0x06, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_OTA_BOOTLOAD_SUCCESS = 0x07, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFTWARE_RESET = 0x08, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_POWER_BUTTON = 0x09, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_TEMPERATURE = 0x0A, - EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BOOTLOAD_FAILURE = 0x0B, +typedef enum +{ + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_UNKNOWN = 0x00, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BATTERY = 0x01, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BROWNOUT = 0x02, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_WATCHDOG = 0x03, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_RESET_PIN = 0x04, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_MEMORY_HARDWARE_FAULT = 0x05, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFWARE_EXCEPTION = 0x06, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_OTA_BOOTLOAD_SUCCESS = 0x07, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_SOFTWARE_RESET = 0x08, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_POWER_BUTTON = 0x09, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_TEMPERATURE = 0x0A, + EMBER_ZCL_WWAH_POWER_NOTIFICATION_REASON_BOOTLOAD_FAILURE = 0x0B, } EmberAfWwahPowerNotificationReason; -typedef enum { - EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_COORDINATOR = 0x00, - EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_ROUTER = 0x01, - EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_END_DEVICE = 0x02, +typedef enum +{ + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_COORDINATOR = 0x00, + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_ROUTER = 0x01, + EMBER_ZCL_ZIGBEE_INFORMATION_LOGICAL_TYPE_END_DEVICE = 0x02, } EmberAfZigbeeInformationLogicalType; -typedef enum { - EMBER_ZCL_ZLL_STATUS_SUCCESS = 0x00, - EMBER_ZCL_ZLL_STATUS_FAILURE = 0x01, +typedef enum +{ + EMBER_ZCL_ZLL_STATUS_SUCCESS = 0x00, + EMBER_ZCL_ZLL_STATUS_FAILURE = 0x01, } EmberAfZllStatus; - #define EMBER_AF_SHADE_CLOSURE_STATUS_OPERATIONAL (0x01) #define EMBER_AF_SHADE_CLOSURE_STATUS_ADJUSTING (0x02) #define EMBER_AF_SHADE_CLOSURE_STATUS_ADJUSTING_OFFSET (1) @@ -2644,15 +2849,21 @@ typedef enum { #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_OVER_VOLTAGE_OFFSET (29) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_POWER (0x0000000040000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_POWER_OFFSET (30) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_VOLTAGE (0x0000000080000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_VOLTAGE \ + (0x0000000080000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVER_VOLTAGE_OFFSET (31) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_REMOTE_LOAD_CONTROL (0x00000000C0000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_REMOTE_LOAD_CONTROL \ + (0x00000000C0000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_REMOTE_LOAD_CONTROL_OFFSET (30) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_BY_OTHER_REMOTE_COMMAND (0x0000000100000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_BY_OTHER_REMOTE_COMMAND \ + (0x0000000100000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_BY_OTHER_REMOTE_COMMAND_OFFSET (32) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT (0x0000000140000000) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT_OFFSET (30) -#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_OTHER (0x0000000180000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT \ + (0x0000000140000000) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_SHORT_CIRCUIT_OFFSET \ + (30) +#define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_OTHER \ + (0x0000000180000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_SERVICE_DISCONNECTION_REASON_OFF_DUE_TO_OVERHEATING_OTHER_OFFSET (31) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_BI_DIRECTIONAL_OPERATION (0x0000000400000000) #define EMBER_AF_METERING_EXTENDED_STATUS_ELECTRICITY_METER_BI_DIRECTIONAL_OPERATION_OFFSET (34) diff --git a/examples/wifi-echo/server/esp32/main/gen/gen_config.h b/examples/wifi-echo/server/esp32/main/gen/gen_config.h index e544d309f7c519..bd3bf01cb8c1cd 100644 --- a/examples/wifi-echo/server/esp32/main/gen/gen_config.h +++ b/examples/wifi-echo/server/esp32/main/gen/gen_config.h @@ -39,25 +39,22 @@ #ifndef SILABS_ZNET_CONFIG #define SILABS_ZNET_CONFIG - /**** Included Header Section ****/ - - // Networks -#define EM_AF_GENERATED_NETWORK_TYPES { \ - EM_AF_NETWORK_TYPE_ZIGBEE_PRO, /* Primary */ \ -} -#define EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS { \ - { \ - /* Primary */ \ - ZA_ROUTER, \ - EMBER_AF_SECURITY_PROFILE_Z3, \ - }, \ -} -#define EM_AF_GENERATED_NETWORK_STRINGS \ - "Primary (pro)", \ -/**** ZCL Section ****/ +#define EM_AF_GENERATED_NETWORK_TYPES \ + { \ + EM_AF_NETWORK_TYPE_ZIGBEE_PRO, /* Primary */ \ + } +#define EM_AF_GENERATED_ZIGBEE_PRO_NETWORKS \ + { \ + { \ + /* Primary */ \ + ZA_ROUTER, \ + EMBER_AF_SECURITY_PROFILE_Z3, \ + }, \ + } +#define EM_AF_GENERATED_NETWORK_STRINGS "Primary (pro)", /**** ZCL Section ****/ #define ZA_PROMPT "ZigbeeMinimalSoc" #define ZCL_USING_ON_OFF_CLUSTER_SERVER #define EMBER_AF_MANUFACTURER_CODE 0x1002 @@ -102,20 +99,18 @@ #define EMBER_AF_PRINT_DEBUG 0x0002 #define EMBER_AF_PRINT_APP 0x0004 #define EMBER_AF_PRINT_ZDO 0x0008 -#define EMBER_AF_PRINT_BITS { 0x0F } -#define EMBER_AF_PRINT_NAMES { \ - "Core",\ - "Debug",\ - "Application",\ - "ZDO (ZigBee Device Object)",\ - NULL\ -} +#define EMBER_AF_PRINT_BITS \ + { \ + 0x0F \ + } +#define EMBER_AF_PRINT_NAMES \ + { \ + "Core", "Debug", "Application", "ZDO (ZigBee Device Object)", NULL \ + } #define EMBER_AF_PRINT_NAME_NUMBER 4 - #define EMBER_AF_SUPPORT_COMMAND_DISCOVERY - // Generated plugin macros // Use this macro to check if Antenna Stub plugin is included @@ -222,36 +217,56 @@ #define EMBER_BROADCAST_TABLE_SIZE 15 #define EMBER_NEIGHBOR_TABLE_SIZE 16 - // Generated API headers // API antenna from Antenna Stub plugin -#define EMBER_AF_API_ANTENNA "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/antenna/antenna.h" +#define EMBER_AF_API_ANTENNA \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/antenna/antenna.h" // API coexistence from Radio Coexistence Stub plugin -#define EMBER_AF_API_COEXISTENCE "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/plugin/coexistence/protocol/ieee802154/coexistence-802154.h" +#define EMBER_AF_API_COEXISTENCE \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/plugin/coexistence/protocol/" \ + "ieee802154/coexistence-802154.h" // API network-steering from Network Steering plugin -#define EMBER_AF_API_NETWORK_STEERING "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/network-steering/network-steering.h" +#define EMBER_AF_API_NETWORK_STEERING \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/network-steering/" \ + "network-steering.h" // API nvm3 from NVM3 Library plugin -#define EMBER_AF_API_NVM3 "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/nvm3/nvm3-token.h" +#define EMBER_AF_API_NVM3 \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/nvm3/nvm3-token.h" // API rail-library from RAIL Library plugin -#define EMBER_AF_API_RAIL_LIBRARY "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/common/rail.h" +#define EMBER_AF_API_RAIL_LIBRARY \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/radio/rail_lib/common/rail.h" // API scan-dispatch from Scan Dispatch plugin -#define EMBER_AF_API_SCAN_DISPATCH "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/scan-dispatch/scan-dispatch.h" +#define EMBER_AF_API_SCAN_DISPATCH \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/scan-dispatch/" \ + "scan-dispatch.h" // API serial from Serial plugin -#define EMBER_AF_API_SERIAL "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/serial/serial.h" +#define EMBER_AF_API_SERIAL \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/serial/serial.h" // API update-tc-link-key from Update TC Link Key plugin -#define EMBER_AF_API_UPDATE_TC_LINK_KEY "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/update-tc-link-key/update-tc-link-key.h" +#define EMBER_AF_API_UPDATE_TC_LINK_KEY \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/framework/plugin/update-tc-link-key/" \ + "update-tc-link-key.h" // API command-interpreter2 from ZCL Framework Core plugin -#define EMBER_AF_API_COMMAND_INTERPRETER2 "../../../../../Applications/Simplicity Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/util/serial/command-interpreter2.h" - +#define EMBER_AF_API_COMMAND_INTERPRETER2 \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/protocol/zigbee/app/util/serial/command-interpreter2.h" // Custom macros #ifdef TRANSITION_TIME_DS @@ -264,6 +279,4 @@ #endif #define FINDING_AND_BINDING_DELAY_MS 3000 - - #endif // SILABS_ZNET_CONFIG diff --git a/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h b/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h index bda4e8c1ad9a9b..80bd8a4098e676 100644 --- a/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h +++ b/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h @@ -37,27 +37,24 @@ // This file contains the tokens for attributes stored in flash - // Identifier tags for tokens - // Types for the tokens #ifdef DEFINETYPES #endif // DEFINETYPES - // Actual token definitions #ifdef DEFINETOKENS #endif // DEFINETOKENS - // Macro snippet that loads all the attributes from tokens -#define GENERATED_TOKEN_LOADER(endpoint) do {\ -} while(false) - +#define GENERATED_TOKEN_LOADER(endpoint) \ + do \ + { \ + } while (false) // Macro snippet that saves the attribute to token -#define GENERATED_TOKEN_SAVER do {\ -} while(false) - - +#define GENERATED_TOKEN_SAVER \ + do \ + { \ + } while (false) diff --git a/examples/wifi-echo/server/esp32/main/gen/print-cluster.h b/examples/wifi-echo/server/esp32/main/gen/print-cluster.h index fc3468704b7f20..87d2771f942629 100644 --- a/examples/wifi-echo/server/esp32/main/gen/print-cluster.h +++ b/examples/wifi-echo/server/esp32/main/gen/print-cluster.h @@ -39,669 +39,740 @@ #ifndef SILABS_PRINT_CLUSTER #define SILABS_PRINT_CLUSTER - // This is the mapping of IDs to cluster names assuming a format according // to the "EmberAfClusterName" defined in the ZCL header. // The names of clusters that are not present, are removed. - - #if defined(ZCL_USING_BASIC_CLUSTER_SERVER) || defined(ZCL_USING_BASIC_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BASIC_CLUSTER {ZCL_BASIC_CLUSTER_ID, 0x0000, "Basic" }, +#define SILABS_PRINTCLUSTER_BASIC_CLUSTER { ZCL_BASIC_CLUSTER_ID, 0x0000, "Basic" }, #else - #define SILABS_PRINTCLUSTER_BASIC_CLUSTER +#define SILABS_PRINTCLUSTER_BASIC_CLUSTER #endif #if defined(ZCL_USING_POWER_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_POWER_CONFIG_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER {ZCL_POWER_CONFIG_CLUSTER_ID, 0x0000, "Power Configuration" }, +#define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER { ZCL_POWER_CONFIG_CLUSTER_ID, 0x0000, "Power Configuration" }, #else - #define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER +#define SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER #endif #if defined(ZCL_USING_DEVICE_TEMP_CLUSTER_SERVER) || defined(ZCL_USING_DEVICE_TEMP_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER {ZCL_DEVICE_TEMP_CLUSTER_ID, 0x0000, "Device Temperature Configuration" }, +#define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER { ZCL_DEVICE_TEMP_CLUSTER_ID, 0x0000, "Device Temperature Configuration" }, #else - #define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER +#define SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER #endif #if defined(ZCL_USING_IDENTIFY_CLUSTER_SERVER) || defined(ZCL_USING_IDENTIFY_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER {ZCL_IDENTIFY_CLUSTER_ID, 0x0000, "Identify" }, +#define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER { ZCL_IDENTIFY_CLUSTER_ID, 0x0000, "Identify" }, #else - #define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER +#define SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER #endif #if defined(ZCL_USING_GROUPS_CLUSTER_SERVER) || defined(ZCL_USING_GROUPS_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_GROUPS_CLUSTER {ZCL_GROUPS_CLUSTER_ID, 0x0000, "Groups" }, +#define SILABS_PRINTCLUSTER_GROUPS_CLUSTER { ZCL_GROUPS_CLUSTER_ID, 0x0000, "Groups" }, #else - #define SILABS_PRINTCLUSTER_GROUPS_CLUSTER +#define SILABS_PRINTCLUSTER_GROUPS_CLUSTER #endif #if defined(ZCL_USING_SCENES_CLUSTER_SERVER) || defined(ZCL_USING_SCENES_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SCENES_CLUSTER {ZCL_SCENES_CLUSTER_ID, 0x0000, "Scenes" }, +#define SILABS_PRINTCLUSTER_SCENES_CLUSTER { ZCL_SCENES_CLUSTER_ID, 0x0000, "Scenes" }, #else - #define SILABS_PRINTCLUSTER_SCENES_CLUSTER +#define SILABS_PRINTCLUSTER_SCENES_CLUSTER #endif #if defined(ZCL_USING_ON_OFF_CLUSTER_SERVER) || defined(ZCL_USING_ON_OFF_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER {ZCL_ON_OFF_CLUSTER_ID, 0x0000, "On/off" }, +#define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER { ZCL_ON_OFF_CLUSTER_ID, 0x0000, "On/off" }, #else - #define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER +#define SILABS_PRINTCLUSTER_ON_OFF_CLUSTER #endif #if defined(ZCL_USING_ON_OFF_SWITCH_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_ON_OFF_SWITCH_CONFIG_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER {ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID, 0x0000, "On/off Switch Configuration" }, +#define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER \ + { ZCL_ON_OFF_SWITCH_CONFIG_CLUSTER_ID, 0x0000, "On/off Switch Configuration" }, #else - #define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER +#define SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER #endif #if defined(ZCL_USING_LEVEL_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_LEVEL_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER {ZCL_LEVEL_CONTROL_CLUSTER_ID, 0x0000, "Level Control" }, +#define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER { ZCL_LEVEL_CONTROL_CLUSTER_ID, 0x0000, "Level Control" }, #else - #define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER #endif #if defined(ZCL_USING_ALARM_CLUSTER_SERVER) || defined(ZCL_USING_ALARM_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ALARM_CLUSTER {ZCL_ALARM_CLUSTER_ID, 0x0000, "Alarms" }, +#define SILABS_PRINTCLUSTER_ALARM_CLUSTER { ZCL_ALARM_CLUSTER_ID, 0x0000, "Alarms" }, #else - #define SILABS_PRINTCLUSTER_ALARM_CLUSTER +#define SILABS_PRINTCLUSTER_ALARM_CLUSTER #endif #if defined(ZCL_USING_TIME_CLUSTER_SERVER) || defined(ZCL_USING_TIME_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TIME_CLUSTER {ZCL_TIME_CLUSTER_ID, 0x0000, "Time" }, +#define SILABS_PRINTCLUSTER_TIME_CLUSTER { ZCL_TIME_CLUSTER_ID, 0x0000, "Time" }, #else - #define SILABS_PRINTCLUSTER_TIME_CLUSTER +#define SILABS_PRINTCLUSTER_TIME_CLUSTER #endif #if defined(ZCL_USING_RSSI_LOCATION_CLUSTER_SERVER) || defined(ZCL_USING_RSSI_LOCATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER {ZCL_RSSI_LOCATION_CLUSTER_ID, 0x0000, "RSSI Location" }, +#define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER { ZCL_RSSI_LOCATION_CLUSTER_ID, 0x0000, "RSSI Location" }, #else - #define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER +#define SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER #endif #if defined(ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_SERVER) || defined(ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER {ZCL_BINARY_INPUT_BASIC_CLUSTER_ID, 0x0000, "Binary Input (Basic)" }, +#define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER { ZCL_BINARY_INPUT_BASIC_CLUSTER_ID, 0x0000, "Binary Input (Basic)" }, #else - #define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER +#define SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER #endif #if defined(ZCL_USING_COMMISSIONING_CLUSTER_SERVER) || defined(ZCL_USING_COMMISSIONING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER {ZCL_COMMISSIONING_CLUSTER_ID, 0x0000, "Commissioning" }, +#define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER { ZCL_COMMISSIONING_CLUSTER_ID, 0x0000, "Commissioning" }, #else - #define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER +#define SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER #endif #if defined(ZCL_USING_PARTITION_CLUSTER_SERVER) || defined(ZCL_USING_PARTITION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PARTITION_CLUSTER {ZCL_PARTITION_CLUSTER_ID, 0x0000, "Partition" }, +#define SILABS_PRINTCLUSTER_PARTITION_CLUSTER { ZCL_PARTITION_CLUSTER_ID, 0x0000, "Partition" }, #else - #define SILABS_PRINTCLUSTER_PARTITION_CLUSTER +#define SILABS_PRINTCLUSTER_PARTITION_CLUSTER #endif #if defined(ZCL_USING_OTA_BOOTLOAD_CLUSTER_SERVER) || defined(ZCL_USING_OTA_BOOTLOAD_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER {ZCL_OTA_BOOTLOAD_CLUSTER_ID, 0x0000, "Over the Air Bootloading" }, +#define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER { ZCL_OTA_BOOTLOAD_CLUSTER_ID, 0x0000, "Over the Air Bootloading" }, #else - #define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER +#define SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER #endif #if defined(ZCL_USING_POWER_PROFILE_CLUSTER_SERVER) || defined(ZCL_USING_POWER_PROFILE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER {ZCL_POWER_PROFILE_CLUSTER_ID, 0x0000, "Power Profile" }, +#define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER { ZCL_POWER_PROFILE_CLUSTER_ID, 0x0000, "Power Profile" }, #else - #define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER +#define SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER #endif #if defined(ZCL_USING_APPLIANCE_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER {ZCL_APPLIANCE_CONTROL_CLUSTER_ID, 0x0000, "Appliance Control" }, +#define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER { ZCL_APPLIANCE_CONTROL_CLUSTER_ID, 0x0000, "Appliance Control" }, #else - #define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER #endif #if defined(ZCL_USING_POLL_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_POLL_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER {ZCL_POLL_CONTROL_CLUSTER_ID, 0x0000, "Poll Control" }, +#define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER { ZCL_POLL_CONTROL_CLUSTER_ID, 0x0000, "Poll Control" }, #else - #define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER #endif #if defined(ZCL_USING_GREEN_POWER_CLUSTER_SERVER) || defined(ZCL_USING_GREEN_POWER_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER {ZCL_GREEN_POWER_CLUSTER_ID, 0x0000, "Green Power" }, +#define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER { ZCL_GREEN_POWER_CLUSTER_ID, 0x0000, "Green Power" }, #else - #define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER +#define SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER #endif #if defined(ZCL_USING_KEEPALIVE_CLUSTER_SERVER) || defined(ZCL_USING_KEEPALIVE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER {ZCL_KEEPALIVE_CLUSTER_ID, 0x0000, "Keep-Alive" }, +#define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER { ZCL_KEEPALIVE_CLUSTER_ID, 0x0000, "Keep-Alive" }, #else - #define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER +#define SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER #endif #if defined(ZCL_USING_SHADE_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_SHADE_CONFIG_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER {ZCL_SHADE_CONFIG_CLUSTER_ID, 0x0000, "Shade Configuration" }, +#define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER { ZCL_SHADE_CONFIG_CLUSTER_ID, 0x0000, "Shade Configuration" }, #else - #define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER +#define SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER #endif #if defined(ZCL_USING_DOOR_LOCK_CLUSTER_SERVER) || defined(ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER {ZCL_DOOR_LOCK_CLUSTER_ID, 0x0000, "Door Lock" }, +#define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER { ZCL_DOOR_LOCK_CLUSTER_ID, 0x0000, "Door Lock" }, #else - #define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER +#define SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER #endif #if defined(ZCL_USING_WINDOW_COVERING_CLUSTER_SERVER) || defined(ZCL_USING_WINDOW_COVERING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER {ZCL_WINDOW_COVERING_CLUSTER_ID, 0x0000, "Window Covering" }, +#define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER { ZCL_WINDOW_COVERING_CLUSTER_ID, 0x0000, "Window Covering" }, #else - #define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER +#define SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER #endif #if defined(ZCL_USING_BARRIER_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_BARRIER_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER {ZCL_BARRIER_CONTROL_CLUSTER_ID, 0x0000, "Barrier Control" }, +#define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER { ZCL_BARRIER_CONTROL_CLUSTER_ID, 0x0000, "Barrier Control" }, #else - #define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER #endif #if defined(ZCL_USING_PUMP_CONFIG_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_PUMP_CONFIG_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER {ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID, 0x0000, "Pump Configuration and Control" }, +#define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER \ + { ZCL_PUMP_CONFIG_CONTROL_CLUSTER_ID, 0x0000, "Pump Configuration and Control" }, #else - #define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER #endif #if defined(ZCL_USING_THERMOSTAT_CLUSTER_SERVER) || defined(ZCL_USING_THERMOSTAT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER {ZCL_THERMOSTAT_CLUSTER_ID, 0x0000, "Thermostat" }, +#define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER { ZCL_THERMOSTAT_CLUSTER_ID, 0x0000, "Thermostat" }, #else - #define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER +#define SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER #endif #if defined(ZCL_USING_FAN_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_FAN_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER {ZCL_FAN_CONTROL_CLUSTER_ID, 0x0000, "Fan Control" }, +#define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER { ZCL_FAN_CONTROL_CLUSTER_ID, 0x0000, "Fan Control" }, #else - #define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER #endif #if defined(ZCL_USING_DEHUMID_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DEHUMID_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER {ZCL_DEHUMID_CONTROL_CLUSTER_ID, 0x0000, "Dehumidification Control" }, +#define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER { ZCL_DEHUMID_CONTROL_CLUSTER_ID, 0x0000, "Dehumidification Control" }, #else - #define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER #endif #if defined(ZCL_USING_THERMOSTAT_UI_CONFIG_CLUSTER_SERVER) || defined(ZCL_USING_THERMOSTAT_UI_CONFIG_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER {ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID, 0x0000, "Thermostat User Interface Configuration" }, +#define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER \ + { ZCL_THERMOSTAT_UI_CONFIG_CLUSTER_ID, 0x0000, "Thermostat User Interface Configuration" }, #else - #define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER +#define SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER #endif #if defined(ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_COLOR_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER {ZCL_COLOR_CONTROL_CLUSTER_ID, 0x0000, "Color Control" }, +#define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER { ZCL_COLOR_CONTROL_CLUSTER_ID, 0x0000, "Color Control" }, #else - #define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER #endif #if defined(ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_SERVER) || defined(ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER {ZCL_BALLAST_CONFIGURATION_CLUSTER_ID, 0x0000, "Ballast Configuration" }, +#define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER { ZCL_BALLAST_CONFIGURATION_CLUSTER_ID, 0x0000, "Ballast Configuration" }, #else - #define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER +#define SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER #endif #if defined(ZCL_USING_ILLUM_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ILLUM_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER {ZCL_ILLUM_MEASUREMENT_CLUSTER_ID, 0x0000, "Illuminance Measurement" }, +#define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER { ZCL_ILLUM_MEASUREMENT_CLUSTER_ID, 0x0000, "Illuminance Measurement" }, #else - #define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_ILLUM_LEVEL_SENSING_CLUSTER_SERVER) || defined(ZCL_USING_ILLUM_LEVEL_SENSING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER {ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID, 0x0000, "Illuminance Level Sensing" }, +#define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER { ZCL_ILLUM_LEVEL_SENSING_CLUSTER_ID, 0x0000, "Illuminance Level Sensing" }, #else - #define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER +#define SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER #endif #if defined(ZCL_USING_TEMP_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TEMP_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER {ZCL_TEMP_MEASUREMENT_CLUSTER_ID, 0x0000, "Temperature Measurement" }, +#define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER { ZCL_TEMP_MEASUREMENT_CLUSTER_ID, 0x0000, "Temperature Measurement" }, #else - #define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER {ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID, 0x0000, "Pressure Measurement" }, +#define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER { ZCL_PRESSURE_MEASUREMENT_CLUSTER_ID, 0x0000, "Pressure Measurement" }, #else - #define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_FLOW_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FLOW_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER {ZCL_FLOW_MEASUREMENT_CLUSTER_ID, 0x0000, "Flow Measurement" }, +#define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER { ZCL_FLOW_MEASUREMENT_CLUSTER_ID, 0x0000, "Flow Measurement" }, #else - #define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER {ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID, 0x0000, "Relative Humidity Measurement" }, +#if defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER \ + { ZCL_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_ID, 0x0000, "Relative Humidity Measurement" }, #else - #define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_OCCUPANCY_SENSING_CLUSTER_SERVER) || defined(ZCL_USING_OCCUPANCY_SENSING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER {ZCL_OCCUPANCY_SENSING_CLUSTER_ID, 0x0000, "Occupancy Sensing" }, +#define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER { ZCL_OCCUPANCY_SENSING_CLUSTER_ID, 0x0000, "Occupancy Sensing" }, #else - #define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER +#define SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER #endif -#if defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Monoxide Concentration Measurement" }, +#if defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Monoxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Dioxide Concentration Measurement" }, +#if defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Carbon Dioxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Concentration Measurement" }, +#if defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Oxide Concentration Measurement" }, +#if defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ethylene Oxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Concentration Measurement" }, +#if defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Sulphide Concentration Measurement" }, +#if defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Hydrogen Sulphide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitric Oxide Concentration Measurement" }, +#if defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitric Oxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitrogen Dioxide Concentration Measurement" }, +#if defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Nitrogen Dioxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Oxygen Concentration Measurement" }, +#if defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Oxygen Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ozone Concentration Measurement" }, +#if defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Ozone Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfur Dioxide Concentration Measurement" }, +#if defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfur Dioxide Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Dissolved Oxygen Concentration Measurement" }, +#if defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Dissolved Oxygen Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromate Concentration Measurement" }, +#if defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromate Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloramines Concentration Measurement" }, +#if defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloramines Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorine Concentration Measurement" }, +#if defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorine Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Fecal coliform and E. Coli Concentration Measurement" }, +#if defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, \ + "Fecal coliform and E. Coli Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Fluoride Concentration Measurement" }, +#if defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Fluoride Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Haloacetic Acids Concentration Measurement" }, +#if defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Haloacetic Acids Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Total Trihalomethanes Concentration Measurement" }, +#if defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Total Trihalomethanes Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Total Coliform Bacteria Concentration Measurement" }, +#if defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, \ + "Total Coliform Bacteria Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Turbidity Concentration Measurement" }, +#if defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Turbidity Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Copper Concentration Measurement" }, +#if defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Copper Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Lead Concentration Measurement" }, +#if defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Lead Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Manganese Concentration Measurement" }, +#if defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Manganese Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfate Concentration Measurement" }, +#if defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sulfate Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromodichloromethane Concentration Measurement" }, +#if defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromodichloromethane Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromoform Concentration Measurement" }, +#if defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Bromoform Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorodibromomethane Concentration Measurement" }, +#if defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chlorodibromomethane Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloroform Concentration Measurement" }, +#if defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Chloroform Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER #endif -#if defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER {ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sodium Concentration Measurement" }, +#if defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_SERVER) || \ + defined(ZCL_USING_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_CLIENT) +#define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER \ + { ZCL_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER_ID, 0x0000, "Sodium Concentration Measurement" }, #else - #define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_IAS_ZONE_CLUSTER_SERVER) || defined(ZCL_USING_IAS_ZONE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER {ZCL_IAS_ZONE_CLUSTER_ID, 0x0000, "IAS Zone" }, +#define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER { ZCL_IAS_ZONE_CLUSTER_ID, 0x0000, "IAS Zone" }, #else - #define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER +#define SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER #endif #if defined(ZCL_USING_IAS_ACE_CLUSTER_SERVER) || defined(ZCL_USING_IAS_ACE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER {ZCL_IAS_ACE_CLUSTER_ID, 0x0000, "IAS ACE" }, +#define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER { ZCL_IAS_ACE_CLUSTER_ID, 0x0000, "IAS ACE" }, #else - #define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER +#define SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER #endif #if defined(ZCL_USING_IAS_WD_CLUSTER_SERVER) || defined(ZCL_USING_IAS_WD_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER {ZCL_IAS_WD_CLUSTER_ID, 0x0000, "IAS WD" }, +#define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER { ZCL_IAS_WD_CLUSTER_ID, 0x0000, "IAS WD" }, #else - #define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER +#define SILABS_PRINTCLUSTER_IAS_WD_CLUSTER #endif #if defined(ZCL_USING_GENERIC_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_GENERIC_TUNNEL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER {ZCL_GENERIC_TUNNEL_CLUSTER_ID, 0x0000, "Generic Tunnel" }, +#define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER { ZCL_GENERIC_TUNNEL_CLUSTER_ID, 0x0000, "Generic Tunnel" }, #else - #define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER +#define SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER #endif #if defined(ZCL_USING_BACNET_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_BACNET_PROTOCOL_TUNNEL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER {ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "BACnet Protocol Tunnel" }, +#define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER \ + { ZCL_BACNET_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "BACnet Protocol Tunnel" }, #else - #define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER +#define SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER #endif #if defined(ZCL_USING_11073_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_11073_PROTOCOL_TUNNEL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER {ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "11073 Protocol Tunnel" }, +#define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER { ZCL_11073_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "11073 Protocol Tunnel" }, #else - #define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER +#define SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER #endif #if defined(ZCL_USING_ISO7816_PROTOCOL_TUNNEL_CLUSTER_SERVER) || defined(ZCL_USING_ISO7816_PROTOCOL_TUNNEL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER {ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "ISO 7816 Protocol Tunnel" }, +#define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER \ + { ZCL_ISO7816_PROTOCOL_TUNNEL_CLUSTER_ID, 0x0000, "ISO 7816 Protocol Tunnel" }, #else - #define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER +#define SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER #endif #if defined(ZCL_USING_PRICE_CLUSTER_SERVER) || defined(ZCL_USING_PRICE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PRICE_CLUSTER {ZCL_PRICE_CLUSTER_ID, 0x0000, "Price" }, +#define SILABS_PRINTCLUSTER_PRICE_CLUSTER { ZCL_PRICE_CLUSTER_ID, 0x0000, "Price" }, #else - #define SILABS_PRINTCLUSTER_PRICE_CLUSTER +#define SILABS_PRINTCLUSTER_PRICE_CLUSTER #endif #if defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER {ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, 0x0000, "Demand Response and Load Control" }, +#define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ + { ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID, 0x0000, "Demand Response and Load Control" }, #else - #define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER #endif #if defined(ZCL_USING_SIMPLE_METERING_CLUSTER_SERVER) || defined(ZCL_USING_SIMPLE_METERING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER {ZCL_SIMPLE_METERING_CLUSTER_ID, 0x0000, "Simple Metering" }, +#define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER { ZCL_SIMPLE_METERING_CLUSTER_ID, 0x0000, "Simple Metering" }, #else - #define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER +#define SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER #endif #if defined(ZCL_USING_MESSAGING_CLUSTER_SERVER) || defined(ZCL_USING_MESSAGING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER {ZCL_MESSAGING_CLUSTER_ID, 0x0000, "Messaging" }, +#define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER { ZCL_MESSAGING_CLUSTER_ID, 0x0000, "Messaging" }, #else - #define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER +#define SILABS_PRINTCLUSTER_MESSAGING_CLUSTER #endif #if defined(ZCL_USING_TUNNELING_CLUSTER_SERVER) || defined(ZCL_USING_TUNNELING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER {ZCL_TUNNELING_CLUSTER_ID, 0x0000, "Tunneling" }, +#define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER { ZCL_TUNNELING_CLUSTER_ID, 0x0000, "Tunneling" }, #else - #define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER +#define SILABS_PRINTCLUSTER_TUNNELING_CLUSTER #endif #if defined(ZCL_USING_PREPAYMENT_CLUSTER_SERVER) || defined(ZCL_USING_PREPAYMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER {ZCL_PREPAYMENT_CLUSTER_ID, 0x0000, "Prepayment" }, +#define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER { ZCL_PREPAYMENT_CLUSTER_ID, 0x0000, "Prepayment" }, #else - #define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER +#define SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER #endif #if defined(ZCL_USING_ENERGY_MANAGEMENT_CLUSTER_SERVER) || defined(ZCL_USING_ENERGY_MANAGEMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER {ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, 0x0000, "Energy Management" }, +#define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER { ZCL_ENERGY_MANAGEMENT_CLUSTER_ID, 0x0000, "Energy Management" }, #else - #define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER +#define SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER #endif #if defined(ZCL_USING_CALENDAR_CLUSTER_SERVER) || defined(ZCL_USING_CALENDAR_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER {ZCL_CALENDAR_CLUSTER_ID, 0x0000, "Calendar" }, +#define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER { ZCL_CALENDAR_CLUSTER_ID, 0x0000, "Calendar" }, #else - #define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER +#define SILABS_PRINTCLUSTER_CALENDAR_CLUSTER #endif #if defined(ZCL_USING_DEVICE_MANAGEMENT_CLUSTER_SERVER) || defined(ZCL_USING_DEVICE_MANAGEMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER {ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, 0x0000, "Device Management" }, +#define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER { ZCL_DEVICE_MANAGEMENT_CLUSTER_ID, 0x0000, "Device Management" }, #else - #define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER +#define SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER #endif #if defined(ZCL_USING_EVENTS_CLUSTER_SERVER) || defined(ZCL_USING_EVENTS_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_EVENTS_CLUSTER {ZCL_EVENTS_CLUSTER_ID, 0x0000, "Events" }, +#define SILABS_PRINTCLUSTER_EVENTS_CLUSTER { ZCL_EVENTS_CLUSTER_ID, 0x0000, "Events" }, #else - #define SILABS_PRINTCLUSTER_EVENTS_CLUSTER +#define SILABS_PRINTCLUSTER_EVENTS_CLUSTER #endif #if defined(ZCL_USING_MDU_PAIRING_CLUSTER_SERVER) || defined(ZCL_USING_MDU_PAIRING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER {ZCL_MDU_PAIRING_CLUSTER_ID, 0x0000, "MDU Pairing" }, +#define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER { ZCL_MDU_PAIRING_CLUSTER_ID, 0x0000, "MDU Pairing" }, #else - #define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER +#define SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER #endif #if defined(ZCL_USING_SUB_GHZ_CLUSTER_SERVER) || defined(ZCL_USING_SUB_GHZ_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER {ZCL_SUB_GHZ_CLUSTER_ID, 0x0000, "Sub-GHz" }, +#define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER { ZCL_SUB_GHZ_CLUSTER_ID, 0x0000, "Sub-GHz" }, #else - #define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER +#define SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER #endif #if defined(ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_SERVER) || defined(ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER {ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, 0x0000, "Key Establishment" }, +#define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER { ZCL_KEY_ESTABLISHMENT_CLUSTER_ID, 0x0000, "Key Establishment" }, #else - #define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER +#define SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER #endif #if defined(ZCL_USING_INFORMATION_CLUSTER_SERVER) || defined(ZCL_USING_INFORMATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER {ZCL_INFORMATION_CLUSTER_ID, 0x0000, "Information" }, +#define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER { ZCL_INFORMATION_CLUSTER_ID, 0x0000, "Information" }, #else - #define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER +#define SILABS_PRINTCLUSTER_INFORMATION_CLUSTER #endif #if defined(ZCL_USING_DATA_SHARING_CLUSTER_SERVER) || defined(ZCL_USING_DATA_SHARING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER {ZCL_DATA_SHARING_CLUSTER_ID, 0x0000, "Data Sharing" }, +#define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER { ZCL_DATA_SHARING_CLUSTER_ID, 0x0000, "Data Sharing" }, #else - #define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER +#define SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER #endif #if defined(ZCL_USING_GAMING_CLUSTER_SERVER) || defined(ZCL_USING_GAMING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_GAMING_CLUSTER {ZCL_GAMING_CLUSTER_ID, 0x0000, "Gaming" }, +#define SILABS_PRINTCLUSTER_GAMING_CLUSTER { ZCL_GAMING_CLUSTER_ID, 0x0000, "Gaming" }, #else - #define SILABS_PRINTCLUSTER_GAMING_CLUSTER +#define SILABS_PRINTCLUSTER_GAMING_CLUSTER #endif #if defined(ZCL_USING_DATA_RATE_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DATA_RATE_CONTROL_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER {ZCL_DATA_RATE_CONTROL_CLUSTER_ID, 0x0000, "Data Rate Control" }, +#define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER { ZCL_DATA_RATE_CONTROL_CLUSTER_ID, 0x0000, "Data Rate Control" }, #else - #define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER +#define SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER #endif #if defined(ZCL_USING_VOICE_OVER_ZIGBEE_CLUSTER_SERVER) || defined(ZCL_USING_VOICE_OVER_ZIGBEE_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER {ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, 0x0000, "Voice over ZigBee" }, +#define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER { ZCL_VOICE_OVER_ZIGBEE_CLUSTER_ID, 0x0000, "Voice over ZigBee" }, #else - #define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER +#define SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER #endif #if defined(ZCL_USING_CHATTING_CLUSTER_SERVER) || defined(ZCL_USING_CHATTING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_CHATTING_CLUSTER {ZCL_CHATTING_CLUSTER_ID, 0x0000, "Chatting" }, +#define SILABS_PRINTCLUSTER_CHATTING_CLUSTER { ZCL_CHATTING_CLUSTER_ID, 0x0000, "Chatting" }, #else - #define SILABS_PRINTCLUSTER_CHATTING_CLUSTER +#define SILABS_PRINTCLUSTER_CHATTING_CLUSTER #endif #if defined(ZCL_USING_PAYMENT_CLUSTER_SERVER) || defined(ZCL_USING_PAYMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER {ZCL_PAYMENT_CLUSTER_ID, 0x0000, "Payment" }, +#define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER { ZCL_PAYMENT_CLUSTER_ID, 0x0000, "Payment" }, #else - #define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER +#define SILABS_PRINTCLUSTER_PAYMENT_CLUSTER #endif #if defined(ZCL_USING_BILLING_CLUSTER_SERVER) || defined(ZCL_USING_BILLING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_BILLING_CLUSTER {ZCL_BILLING_CLUSTER_ID, 0x0000, "Billing" }, +#define SILABS_PRINTCLUSTER_BILLING_CLUSTER { ZCL_BILLING_CLUSTER_ID, 0x0000, "Billing" }, #else - #define SILABS_PRINTCLUSTER_BILLING_CLUSTER +#define SILABS_PRINTCLUSTER_BILLING_CLUSTER #endif #if defined(ZCL_USING_APPLIANCE_IDENTIFICATION_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_IDENTIFICATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER {ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID, 0x0000, "Appliance Identification" }, +#define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER \ + { ZCL_APPLIANCE_IDENTIFICATION_CLUSTER_ID, 0x0000, "Appliance Identification" }, #else - #define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER +#define SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER #endif #if defined(ZCL_USING_METER_IDENTIFICATION_CLUSTER_SERVER) || defined(ZCL_USING_METER_IDENTIFICATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER {ZCL_METER_IDENTIFICATION_CLUSTER_ID, 0x0000, "Meter Identification" }, +#define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER { ZCL_METER_IDENTIFICATION_CLUSTER_ID, 0x0000, "Meter Identification" }, #else - #define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER +#define SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER #endif #if defined(ZCL_USING_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER {ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, 0x0000, "Appliance Events and Alert" }, +#define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER \ + { ZCL_APPLIANCE_EVENTS_AND_ALERT_CLUSTER_ID, 0x0000, "Appliance Events and Alert" }, #else - #define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER +#define SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER #endif #if defined(ZCL_USING_APPLIANCE_STATISTICS_CLUSTER_SERVER) || defined(ZCL_USING_APPLIANCE_STATISTICS_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER {ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, 0x0000, "Appliance Statistics" }, +#define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER { ZCL_APPLIANCE_STATISTICS_CLUSTER_ID, 0x0000, "Appliance Statistics" }, #else - #define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER +#define SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER #endif #if defined(ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_SERVER) || defined(ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER {ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, 0x0000, "Electrical Measurement" }, +#define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER \ + { ZCL_ELECTRICAL_MEASUREMENT_CLUSTER_ID, 0x0000, "Electrical Measurement" }, #else - #define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER +#define SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER #endif #if defined(ZCL_USING_DIAGNOSTICS_CLUSTER_SERVER) || defined(ZCL_USING_DIAGNOSTICS_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER {ZCL_DIAGNOSTICS_CLUSTER_ID, 0x0000, "Diagnostics" }, +#define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER { ZCL_DIAGNOSTICS_CLUSTER_ID, 0x0000, "Diagnostics" }, #else - #define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER +#define SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER #endif #if defined(ZCL_USING_ZLL_COMMISSIONING_CLUSTER_SERVER) || defined(ZCL_USING_ZLL_COMMISSIONING_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER {ZCL_ZLL_COMMISSIONING_CLUSTER_ID, 0x0000, "ZLL Commissioning" }, +#define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER { ZCL_ZLL_COMMISSIONING_CLUSTER_ID, 0x0000, "ZLL Commissioning" }, #else - #define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER +#define SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER #endif #if defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_SERVER) || defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER {ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, 0x1002, "Sample Mfg Specific Cluster" }, +#define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER \ + { ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_ID, 0x1002, "Sample Mfg Specific Cluster" }, #else - #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER +#define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER #endif #if defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_2_SERVER) || defined(ZCL_USING_SAMPLE_MFG_SPECIFIC_CLUSTER_2_CLIENT) - #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 {ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, 0x1049, "Sample Mfg Specific Cluster 2" }, +#define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 \ + { ZCL_SAMPLE_MFG_SPECIFIC_CLUSTER_2_ID, 0x1049, "Sample Mfg Specific Cluster 2" }, #else - #define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 +#define SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 #endif #if defined(ZCL_USING_OTA_CONFIGURATION_CLUSTER_SERVER) || defined(ZCL_USING_OTA_CONFIGURATION_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER {ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, "Configuration Cluster" }, +#define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER { ZCL_OTA_CONFIGURATION_CLUSTER_ID, 0x1002, "Configuration Cluster" }, #else - #define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER +#define SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER #endif #if defined(ZCL_USING_MFGLIB_CLUSTER_SERVER) || defined(ZCL_USING_MFGLIB_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER {ZCL_MFGLIB_CLUSTER_ID, 0x1002, "MFGLIB Cluster" }, +#define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER { ZCL_MFGLIB_CLUSTER_ID, 0x1002, "MFGLIB Cluster" }, #else - #define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER +#define SILABS_PRINTCLUSTER_MFGLIB_CLUSTER #endif #if defined(ZCL_USING_SL_WWAH_CLUSTER_SERVER) || defined(ZCL_USING_SL_WWAH_CLUSTER_CLIENT) - #define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER {ZCL_SL_WWAH_CLUSTER_ID, 0x1217, "SL Works With All Hubs" }, -#else - #define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER -#endif -#define CLUSTER_IDS_TO_NAMES \ - SILABS_PRINTCLUSTER_BASIC_CLUSTER \ - SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER \ - SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER \ - SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER \ - SILABS_PRINTCLUSTER_GROUPS_CLUSTER \ - SILABS_PRINTCLUSTER_SCENES_CLUSTER \ - SILABS_PRINTCLUSTER_ON_OFF_CLUSTER \ - SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER \ - SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_ALARM_CLUSTER \ - SILABS_PRINTCLUSTER_TIME_CLUSTER \ - SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER \ - SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER \ - SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER \ - SILABS_PRINTCLUSTER_PARTITION_CLUSTER \ - SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER \ - SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER \ - SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER \ - SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER \ - SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER \ - SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ - SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ - SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER \ - SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER \ - SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER \ - SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER \ - SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER \ - SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER \ - SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER \ - SILABS_PRINTCLUSTER_IAS_WD_CLUSTER \ - SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER \ - SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER \ - SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER \ - SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER \ - SILABS_PRINTCLUSTER_PRICE_CLUSTER \ - SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER \ - SILABS_PRINTCLUSTER_MESSAGING_CLUSTER \ - SILABS_PRINTCLUSTER_TUNNELING_CLUSTER \ - SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER \ - SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER \ - SILABS_PRINTCLUSTER_CALENDAR_CLUSTER \ - SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER \ - SILABS_PRINTCLUSTER_EVENTS_CLUSTER \ - SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER \ - SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER \ - SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER \ - SILABS_PRINTCLUSTER_INFORMATION_CLUSTER \ - SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER \ - SILABS_PRINTCLUSTER_GAMING_CLUSTER \ - SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER \ - SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER \ - SILABS_PRINTCLUSTER_CHATTING_CLUSTER \ - SILABS_PRINTCLUSTER_PAYMENT_CLUSTER \ - SILABS_PRINTCLUSTER_BILLING_CLUSTER \ - SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER \ - SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER \ - SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER \ - SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER \ - SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER \ - SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER \ - SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER \ - SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER \ - SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 \ - SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER \ - SILABS_PRINTCLUSTER_MFGLIB_CLUSTER \ - SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER \ - +#define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER { ZCL_SL_WWAH_CLUSTER_ID, 0x1217, "SL Works With All Hubs" }, +#else +#define SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER +#endif +#define CLUSTER_IDS_TO_NAMES \ + SILABS_PRINTCLUSTER_BASIC_CLUSTER \ + SILABS_PRINTCLUSTER_POWER_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_DEVICE_TEMP_CLUSTER \ + SILABS_PRINTCLUSTER_IDENTIFY_CLUSTER \ + SILABS_PRINTCLUSTER_GROUPS_CLUSTER \ + SILABS_PRINTCLUSTER_SCENES_CLUSTER \ + SILABS_PRINTCLUSTER_ON_OFF_CLUSTER \ + SILABS_PRINTCLUSTER_ON_OFF_SWITCH_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_LEVEL_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_ALARM_CLUSTER \ + SILABS_PRINTCLUSTER_TIME_CLUSTER \ + SILABS_PRINTCLUSTER_RSSI_LOCATION_CLUSTER \ + SILABS_PRINTCLUSTER_BINARY_INPUT_BASIC_CLUSTER \ + SILABS_PRINTCLUSTER_COMMISSIONING_CLUSTER \ + SILABS_PRINTCLUSTER_PARTITION_CLUSTER \ + SILABS_PRINTCLUSTER_OTA_BOOTLOAD_CLUSTER \ + SILABS_PRINTCLUSTER_POWER_PROFILE_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_POLL_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_GREEN_POWER_CLUSTER \ + SILABS_PRINTCLUSTER_KEEPALIVE_CLUSTER \ + SILABS_PRINTCLUSTER_SHADE_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ + SILABS_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ + SILABS_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_PUMP_CONFIG_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_THERMOSTAT_CLUSTER \ + SILABS_PRINTCLUSTER_FAN_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_DEHUMID_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_THERMOSTAT_UI_CONFIG_CLUSTER \ + SILABS_PRINTCLUSTER_COLOR_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_BALLAST_CONFIGURATION_CLUSTER \ + SILABS_PRINTCLUSTER_ILLUM_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ILLUM_LEVEL_SENSING_CLUSTER \ + SILABS_PRINTCLUSTER_TEMP_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_PRESSURE_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FLOW_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OCCUPANCY_SENSING_CLUSTER \ + SILABS_PRINTCLUSTER_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_ZONE_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_ACE_CLUSTER \ + SILABS_PRINTCLUSTER_IAS_WD_CLUSTER \ + SILABS_PRINTCLUSTER_GENERIC_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_BACNET_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_11073_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_ISO7816_PROTOCOL_TUNNEL_CLUSTER \ + SILABS_PRINTCLUSTER_PRICE_CLUSTER \ + SILABS_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_SIMPLE_METERING_CLUSTER \ + SILABS_PRINTCLUSTER_MESSAGING_CLUSTER \ + SILABS_PRINTCLUSTER_TUNNELING_CLUSTER \ + SILABS_PRINTCLUSTER_PREPAYMENT_CLUSTER \ + SILABS_PRINTCLUSTER_ENERGY_MANAGEMENT_CLUSTER \ + SILABS_PRINTCLUSTER_CALENDAR_CLUSTER \ + SILABS_PRINTCLUSTER_DEVICE_MANAGEMENT_CLUSTER \ + SILABS_PRINTCLUSTER_EVENTS_CLUSTER \ + SILABS_PRINTCLUSTER_MDU_PAIRING_CLUSTER \ + SILABS_PRINTCLUSTER_SUB_GHZ_CLUSTER \ + SILABS_PRINTCLUSTER_KEY_ESTABLISHMENT_CLUSTER \ + SILABS_PRINTCLUSTER_INFORMATION_CLUSTER \ + SILABS_PRINTCLUSTER_DATA_SHARING_CLUSTER \ + SILABS_PRINTCLUSTER_GAMING_CLUSTER \ + SILABS_PRINTCLUSTER_DATA_RATE_CONTROL_CLUSTER \ + SILABS_PRINTCLUSTER_VOICE_OVER_ZIGBEE_CLUSTER \ + SILABS_PRINTCLUSTER_CHATTING_CLUSTER \ + SILABS_PRINTCLUSTER_PAYMENT_CLUSTER \ + SILABS_PRINTCLUSTER_BILLING_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_IDENTIFICATION_CLUSTER \ + SILABS_PRINTCLUSTER_METER_IDENTIFICATION_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_EVENTS_AND_ALERT_CLUSTER \ + SILABS_PRINTCLUSTER_APPLIANCE_STATISTICS_CLUSTER \ + SILABS_PRINTCLUSTER_ELECTRICAL_MEASUREMENT_CLUSTER \ + SILABS_PRINTCLUSTER_DIAGNOSTICS_CLUSTER \ + SILABS_PRINTCLUSTER_ZLL_COMMISSIONING_CLUSTER \ + SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER \ + SILABS_PRINTCLUSTER_SAMPLE_MFG_SPECIFIC_CLUSTER_2 \ + SILABS_PRINTCLUSTER_OTA_CONFIGURATION_CLUSTER \ + SILABS_PRINTCLUSTER_MFGLIB_CLUSTER \ + SILABS_PRINTCLUSTER_SL_WWAH_CLUSTER -#define MAX_CLUSTER_NAME_LENGTH 52 +#define MAX_CLUSTER_NAME_LENGTH 52 #endif // SILABS_PRINT_CLUSTER diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c index 41e313d6fdabab..4aa0e414883c13 100644 --- a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c @@ -40,82 +40,83 @@ #include "../af.h" // Init function declarations. -void emberAfMainInitCallback(void); // Global -void emberAfInit(void); // Global +void emberAfMainInitCallback(void); // Global +void emberAfInit(void); // Global void emAfInit(void) { - emberAfMainInitCallback(); // Global - emberAfInit(); // Global + emberAfMainInitCallback(); // Global + emberAfInit(); // Global } // Tick function declarations. -void emberAfMainTickCallback(void); // Global -void emberAfTick(void); // Global +void emberAfMainTickCallback(void); // Global +void emberAfTick(void); // Global void emAfTick(void) { - emberAfMainTickCallback(); // Global - emberAfTick(); // Global + emberAfMainTickCallback(); // Global + emberAfTick(); // Global } // Marker function declarations. -void emberAfMarkBuffersCallback(void); // Global -void emberAfPluginNetworkSteeringMarker(void); // Plugin: network-steering +void emberAfMarkBuffersCallback(void); // Global +void emberAfPluginNetworkSteeringMarker(void); // Plugin: network-steering void emAfMarkBuffers(void) { - emberAfMarkBuffersCallback(); // Global - emberAfPluginNetworkSteeringMarker(); // Plugin: network-steering + emberAfMarkBuffersCallback(); // Global + emberAfPluginNetworkSteeringMarker(); // Plugin: network-steering } -void emAfResetAttributes(uint8_t endpointId) -{ -} +void emAfResetAttributes(uint8_t endpointId) {} // PreCommandReceived function declarations. -bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand* cmd); // Global +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd); // Global -bool emAfPreCommandReceived(EmberAfClusterCommand* cmd) +bool emAfPreCommandReceived(EmberAfClusterCommand * cmd) { - return emberAfPreCommandReceivedCallback(cmd); // Global + return emberAfPreCommandReceivedCallback(cmd); // Global } // PreZDOMessageReceived function declarations. -bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length); // Global +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, + uint16_t length); // Global -bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length) +bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length) { - return emberAfPreZDOMessageReceivedCallback(emberNodeId, apsFrame, message, length); // Global + return emberAfPreZDOMessageReceivedCallback(emberNodeId, apsFrame, message, length); // Global } -bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength) +bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, + uint16_t maunfacturerCode, uint16_t readLength) { - return 0; // false + return 0; // false } // ZigbeeKeyEstablishment function declarations. -void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Global -void emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Plugin: update-tc-link-key +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); // Global +void emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(EmberEUI64 partner, + EmberKeyStatus status); // Plugin: update-tc-link-key void emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status) { - emberAfZigbeeKeyEstablishmentCallback(partner, status); // Global - emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(partner, status); // Plugin: update-tc-link-key + emberAfZigbeeKeyEstablishmentCallback(partner, status); // Global + emberAfPluginUpdateTcLinkKeyZigbeeKeyEstablishmentCallback(partner, status); // Plugin: update-tc-link-key } // ReadAttributesResponse function declarations. -bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen); // Global +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); // Global -bool emAfReadAttributesResponse(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen) +bool emAfReadAttributesResponse(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return emberAfReadAttributesResponseCallback(clusterId, buffer, bufLen); // Global + return emberAfReadAttributesResponseCallback(clusterId, buffer, bufLen); // Global } // ReportAttributes function declarations. -bool emberAfReportAttributesCallback(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen); // Global +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); // Global -bool emAfReportAttributes(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen) +bool emAfReportAttributes(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) { - return emberAfReportAttributesCallback(clusterId, buffer, bufLen); // Global + return emberAfReportAttributesCallback(clusterId, buffer, bufLen); // Global } diff --git a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h index 18aa71caadf577..1fafa460393ba9 100644 --- a/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.h @@ -39,7 +39,6 @@ #ifndef SILABS_ZNET_BOOKKEEPING_H #define SILABS_ZNET_BOOKKEEPING_H - //#include PLATFORM_HEADER //#include CONFIGURATION_HEADER #include "../af.h" @@ -52,16 +51,17 @@ void emAfMarkBuffers(void); void emAfResetAttributes(uint8_t endpointId); -bool emAfPreCommandReceived(EmberAfClusterCommand* cmd); +bool emAfPreCommandReceived(EmberAfClusterCommand * cmd); -bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId,EmberApsFrame* apsFrame,uint8_t* message,uint16_t length); +bool emAfPreZDOMessageReceived(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length); -bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, uint16_t maunfacturerCode, uint16_t readLength); +bool emAfRetrieveAttributeAndCraftResponse(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attrId, uint8_t mask, + uint16_t maunfacturerCode, uint16_t readLength); void emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status); -bool emAfReadAttributesResponse(EmberAfClusterId clusterId,uint8_t* buffer,uint16_t bufLen); +bool emAfReadAttributesResponse(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); -bool emAfReportAttributes(EmberAfClusterId clusterId,uint8_t * buffer,uint16_t bufLen); +bool emAfReportAttributes(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); #endif // SILABS_ZNET_BOOKKEEPING_H diff --git a/examples/wifi-echo/server/esp32/main/message.c b/examples/wifi-echo/server/esp32/main/message.c index aef30d2b38b6b9..78b9c669520d05 100644 --- a/examples/wifi-echo/server/esp32/main/message.c +++ b/examples/wifi-echo/server/esp32/main/message.c @@ -31,16 +31,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief Code for manipulating the incoming and outgoing messages in a flat - * memory buffer. + * @brief Code for manipulating the incoming and + *outgoing messages in a flat memory buffer. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #include "af.h" -#include "util.h" #include "config.h" +#include "util.h" //------------------------------------------------------------------------------ @@ -51,14 +52,14 @@ // only result in a single call to emberIncomingMsgHandler. If the device // receives multiple ZCL messages, the stack will queue these and hand // these to the application via emberIncomingMsgHandler one at a time. -EmberApsFrame emberAfResponseApsFrame; -EmberNodeId emberAfResponseDestination; -uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; -uint16_t appResponseLength; +EmberApsFrame emberAfResponseApsFrame; +EmberNodeId emberAfResponseDestination; +uint8_t appResponseData[EMBER_AF_RESPONSE_BUFFER_LEN]; +uint16_t appResponseLength; // Used for empty string -static uint16_t zeroLenByte = 0; -static uint8_t* zeroLenBytePtr = (uint8_t *)&zeroLenByte; +static uint16_t zeroLenByte = 0; +static uint8_t * zeroLenBytePtr = (uint8_t *) &zeroLenByte; //------------------------------------------------------------------------------ // Utilities for adding bytes to the response buffer: appResponseData. These @@ -66,96 +67,112 @@ static uint8_t* zeroLenBytePtr = (uint8_t *)&zeroLenByte; void emberAfClearResponseData(void) { - emberAfResponseType = ZCL_UTIL_RESP_NORMAL; - // To prevent accidentally sending to someone else, - // set the destination to ourselves. - emberAfResponseDestination = 0 /* emberAfGetNodeId() */; - MEMSET(appResponseData, 0, EMBER_AF_RESPONSE_BUFFER_LEN); - appResponseLength = 0; - MEMSET(&emberAfResponseApsFrame, 0, sizeof(EmberApsFrame)); + emberAfResponseType = ZCL_UTIL_RESP_NORMAL; + // To prevent accidentally sending to someone else, + // set the destination to ourselves. + emberAfResponseDestination = 0 /* emberAfGetNodeId() */; + MEMSET(appResponseData, 0, EMBER_AF_RESPONSE_BUFFER_LEN); + appResponseLength = 0; + MEMSET(&emberAfResponseApsFrame, 0, sizeof(EmberApsFrame)); } uint8_t * emberAfPutInt8uInResp(uint8_t value) { - //emberAfDebugPrint("try %x max %x\r\n", appResponseLength, EMBER_AF_RESPONSE_BUFFER_LEN); - if (appResponseLength < EMBER_AF_RESPONSE_BUFFER_LEN) { - //emberAfDebugPrint("put %x at spot %x\r\n", value, appResponseLength); - appResponseData[appResponseLength] = value; - appResponseLength++; - return &appResponseData[appResponseLength - 1]; - } - - return NULL; + // emberAfDebugPrint("try %x max %x\r\n", appResponseLength, EMBER_AF_RESPONSE_BUFFER_LEN); + if (appResponseLength < EMBER_AF_RESPONSE_BUFFER_LEN) + { + // emberAfDebugPrint("put %x at spot %x\r\n", value, appResponseLength); + appResponseData[appResponseLength] = value; + appResponseLength++; + return &appResponseData[appResponseLength - 1]; + } + + return NULL; } uint16_t * emberAfPutInt16uInResp(uint16_t value) { - uint8_t * low = emberAfPutInt8uInResp(LOW_BYTE(value)); - uint8_t * high = emberAfPutInt8uInResp(HIGH_BYTE(value)); - - if (low && high) { - return (uint16_t *) low; - } else { - return NULL; - } + uint8_t * low = emberAfPutInt8uInResp(LOW_BYTE(value)); + uint8_t * high = emberAfPutInt8uInResp(HIGH_BYTE(value)); + + if (low && high) + { + return (uint16_t *) low; + } + else + { + return NULL; + } } uint32_t * emberAfPutInt32uInResp(uint32_t value) { - uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); - uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); - uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); - uint8_t * d = emberAfPutInt8uInResp(BYTE_3(value)); - - if (a && b && c && d) { - return (uint32_t *)a; - } else { - return NULL; - } + uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); + uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); + uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); + uint8_t * d = emberAfPutInt8uInResp(BYTE_3(value)); + + if (a && b && c && d) + { + return (uint32_t *) a; + } + else + { + return NULL; + } } uint32_t * emberAfPutInt24uInResp(uint32_t value) { - uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); - uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); - uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); - - if (a && b && c) { - return (uint32_t *) a; - } else { - return NULL; - } + uint8_t * a = emberAfPutInt8uInResp(BYTE_0(value)); + uint8_t * b = emberAfPutInt8uInResp(BYTE_1(value)); + uint8_t * c = emberAfPutInt8uInResp(BYTE_2(value)); + + if (a && b && c) + { + return (uint32_t *) a; + } + else + { + return NULL; + } } -uint8_t * emberAfPutBlockInResp(const uint8_t* data, uint16_t length) +uint8_t * emberAfPutBlockInResp(const uint8_t * data, uint16_t length) { - if ((appResponseLength + length) < EMBER_AF_RESPONSE_BUFFER_LEN) { - MEMMOVE(appResponseData + appResponseLength, data, length); - appResponseLength += length; - return &appResponseData[appResponseLength - length]; - } else { - return NULL; - } + if ((appResponseLength + length) < EMBER_AF_RESPONSE_BUFFER_LEN) + { + MEMMOVE(appResponseData + appResponseLength, data, length); + appResponseLength += length; + return &appResponseData[appResponseLength - length]; + } + else + { + return NULL; + } } -uint8_t * emberAfPutStringInResp(const uint8_t *buffer) +uint8_t * emberAfPutStringInResp(const uint8_t * buffer) { - uint8_t length = emberAfStringLength(buffer); - return emberAfPutBlockInResp(buffer, length + 1); + uint8_t length = emberAfStringLength(buffer); + return emberAfPutBlockInResp(buffer, length + 1); } -uint8_t * emberAfPutDateInResp(EmberAfDate *value) +uint8_t * emberAfPutDateInResp(EmberAfDate * value) { - uint8_t * a = emberAfPutInt8uInResp(value->year); - uint8_t * b = emberAfPutInt8uInResp(value->month); - uint8_t * c = emberAfPutInt8uInResp(value->dayOfMonth); - uint8_t * d = emberAfPutInt8uInResp(value->dayOfWeek); - - if (a && b && c && d) { - return a; - } else { - return NULL; - } + uint8_t * a = emberAfPutInt8uInResp(value->year); + uint8_t * b = emberAfPutInt8uInResp(value->month); + uint8_t * c = emberAfPutInt8uInResp(value->dayOfMonth); + uint8_t * d = emberAfPutInt8uInResp(value->dayOfWeek); + + if (a && b && c && d) + { + return a; + } + else + { + return NULL; + } } // ------------------------------------ @@ -165,105 +182,105 @@ uint8_t * emberAfPutDateInResp(EmberAfDate *value) // retrieves an uint32_t which contains between 1 and 4 bytes of relevent data // depending on number of bytes requested. -uint32_t emberAfGetInt(const uint8_t* message, - uint16_t currentIndex, - uint16_t msgLen, - uint8_t bytes) +uint32_t emberAfGetInt(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen, uint8_t bytes) { - uint32_t result = 0; - uint8_t i = bytes; - if ((currentIndex + bytes) > msgLen) { - emberAfDebugPrintln("GetInt, %x bytes short", bytes); - emberAfDebugFlush(); - return 0; - } - while (i > 0) { - result = (result << 8) + message[(currentIndex + i) - 1]; - i--; - } - return result; + uint32_t result = 0; + uint8_t i = bytes; + if ((currentIndex + bytes) > msgLen) + { + emberAfDebugPrintln("GetInt, %x bytes short", bytes); + emberAfDebugFlush(); + return 0; + } + while (i > 0) + { + result = (result << 8) + message[(currentIndex + i) - 1]; + i--; + } + return result; } -uint32_t emberAfGetInt32u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +uint32_t emberAfGetInt32u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen) { - return emberAfGetInt(message, currentIndex, msgLen, 4); + return emberAfGetInt(message, currentIndex, msgLen, 4); } -uint32_t emberAfGetInt24u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +uint32_t emberAfGetInt24u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen) { - return emberAfGetInt(message, currentIndex, msgLen, 3); + return emberAfGetInt(message, currentIndex, msgLen, 3); } -uint16_t emberAfGetInt16u(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +uint16_t emberAfGetInt16u(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen) { - return (uint16_t)emberAfGetInt(message, currentIndex, msgLen, 2); + return (uint16_t) emberAfGetInt(message, currentIndex, msgLen, 2); } -uint8_t* emberAfGetString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +uint8_t * emberAfGetString(uint8_t * message, uint16_t currentIndex, uint16_t msgLen) { - // Strings must contain at least one byte for the length. - if (msgLen <= currentIndex) { - emberAfDebugPrintln("GetString: %p", "buffer too short"); - return zeroLenBytePtr; - } - - // Starting from the current index, there must be enough bytes in the message - // for the string and the length byte. - if (msgLen < currentIndex + emberAfStringLength(&message[currentIndex]) + 1) { - emberAfDebugPrintln("GetString: %p", "len byte wrong"); - return zeroLenBytePtr; - } - - return &message[currentIndex]; + // Strings must contain at least one byte for the length. + if (msgLen <= currentIndex) + { + emberAfDebugPrintln("GetString: %p", "buffer too short"); + return zeroLenBytePtr; + } + + // Starting from the current index, there must be enough bytes in the message + // for the string and the length byte. + if (msgLen < currentIndex + emberAfStringLength(&message[currentIndex]) + 1) + { + emberAfDebugPrintln("GetString: %p", "len byte wrong"); + return zeroLenBytePtr; + } + + return &message[currentIndex]; } -uint8_t* emberAfGetLongString(uint8_t* message, uint16_t currentIndex, uint16_t msgLen) +uint8_t * emberAfGetLongString(uint8_t * message, uint16_t currentIndex, uint16_t msgLen) { - // Long strings must contain at least two bytes for the length. - if (msgLen <= currentIndex + 1) { - emberAfDebugPrintln("GetLongString: %p", "buffer too short"); - return zeroLenBytePtr; - } - - // Starting from the current index, there must be enough bytes in the message - // for the string and the length bytes. - if (msgLen - < currentIndex + emberAfLongStringLength(&message[currentIndex]) + 2) { - emberAfDebugPrintln("GetLongString: %p", "len bytes wrong"); - return zeroLenBytePtr; - } - - return &message[currentIndex]; + // Long strings must contain at least two bytes for the length. + if (msgLen <= currentIndex + 1) + { + emberAfDebugPrintln("GetLongString: %p", "buffer too short"); + return zeroLenBytePtr; + } + + // Starting from the current index, there must be enough bytes in the message + // for the string and the length bytes. + if (msgLen < currentIndex + emberAfLongStringLength(&message[currentIndex]) + 2) + { + emberAfDebugPrintln("GetLongString: %p", "len bytes wrong"); + return zeroLenBytePtr; + } + + return &message[currentIndex]; } -uint8_t emberAfStringLength(const uint8_t *buffer) +uint8_t emberAfStringLength(const uint8_t * buffer) { - // The first byte specifies the length of the string. A length of 0xFF means - // the string is invalid and there is no character data. - return (buffer[0] == 0xFF ? 0 : buffer[0]); + // The first byte specifies the length of the string. A length of 0xFF means + // the string is invalid and there is no character data. + return (buffer[0] == 0xFF ? 0 : buffer[0]); } -uint16_t emberAfLongStringLength(const uint8_t *buffer) +uint16_t emberAfLongStringLength(const uint8_t * buffer) { - // The first two bytes specify the length of the long string. A length of - // 0xFFFF means the string is invalid and there is no character data. - uint16_t length = emberAfGetInt16u(buffer, 0, 2); - return (length == 0xFFFF ? 0 : length); + // The first two bytes specify the length of the long string. A length of + // 0xFFFF means the string is invalid and there is no character data. + uint16_t length = emberAfGetInt16u(buffer, 0, 2); + return (length == 0xFFFF ? 0 : length); } -uint8_t emberAfGetDate(uint8_t* message, - uint16_t currentIndex, - uint16_t msgLen, - EmberAfDate *destination) +uint8_t emberAfGetDate(uint8_t * message, uint16_t currentIndex, uint16_t msgLen, EmberAfDate * destination) { - if ((currentIndex + 4) > msgLen) { - emberAfDebugPrintln("GetDate, %x bytes short", 4); - emberAfDebugFlush(); - return 0; - } - destination->year = message[(currentIndex + 0)]; - destination->month = message[(currentIndex + 1)]; - destination->dayOfMonth = message[(currentIndex + 2)]; - destination->dayOfWeek = message[(currentIndex + 3)]; - return 4; + if ((currentIndex + 4) > msgLen) + { + emberAfDebugPrintln("GetDate, %x bytes short", 4); + emberAfDebugFlush(); + return 0; + } + destination->year = message[(currentIndex + 0)]; + destination->month = message[(currentIndex + 1)]; + destination->dayOfMonth = message[(currentIndex + 2)]; + destination->dayOfWeek = message[(currentIndex + 3)]; + return 4; } diff --git a/examples/wifi-echo/server/esp32/main/on-off.c b/examples/wifi-echo/server/esp32/main/on-off.c index a21a046f9cf782..6cb40455ab055e 100644 --- a/examples/wifi-echo/server/esp32/main/on-off.c +++ b/examples/wifi-echo/server/esp32/main/on-off.c @@ -31,271 +31,247 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief Routines for the On-Off plugin, which implements the On-Off server - * cluster. + * @brief Routines for the On-Off plugin, which + *implements the On-Off server cluster. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #include "af.h" #ifdef EMBER_AF_PLUGIN_REPORTING - #include "app/framework/plugin/reporting/reporting.h" +#include "app/framework/plugin/reporting/reporting.h" #endif #ifdef EMBER_AF_PLUGIN_SCENES - #include "../scenes/scenes.h" -#endif //EMBER_AF_PLUGIN_SCENES +#include "../scenes/scenes.h" +#endif // EMBER_AF_PLUGIN_SCENES #ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER - #include "../zll-on-off-server/zll-on-off-server.h" +#include "../zll-on-off-server/zll-on-off-server.h" #endif #ifdef EMBER_AF_PLUGIN_ZLL_LEVEL_CONTROL_SERVER - #include "../zll-level-control-server/zll-level-control-server.h" +#include "../zll-level-control-server/zll-level-control-server.h" #endif #ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE static bool areStartUpOnOffServerAttributesTokenized(uint8_t endpoint); #endif -EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, - uint8_t command, - bool initiatedByLevelChange) +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange) { - EmberAfStatus status; - bool currentValue, newValue; + EmberAfStatus status; + bool currentValue, newValue; - emberAfOnOffClusterPrintln("On/Off set value: %x %x", endpoint, command); + emberAfOnOffClusterPrintln("On/Off set value: %x %x", endpoint, command); - // read current on/off value - status = emberAfReadAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)¤tValue, - sizeof(currentValue), - NULL); // data type - if (status != EMBER_ZCL_STATUS_SUCCESS) { - emberAfOnOffClusterPrintln("ERR: reading on/off %x", status); - return status; - } + // read current on/off value + status = emberAfReadAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + (uint8_t *) ¤tValue, sizeof(currentValue), + NULL); // data type + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + emberAfOnOffClusterPrintln("ERR: reading on/off %x", status); + return status; + } - // if the value is already what we want to set it to then do nothing - if ((!currentValue && command == ZCL_OFF_COMMAND_ID) - || (currentValue && command == ZCL_ON_COMMAND_ID)) { - emberAfOnOffClusterPrintln("On/off already set to new value"); - return EMBER_ZCL_STATUS_SUCCESS; - } + // if the value is already what we want to set it to then do nothing + if ((!currentValue && command == ZCL_OFF_COMMAND_ID) || (currentValue && command == ZCL_ON_COMMAND_ID)) + { + emberAfOnOffClusterPrintln("On/off already set to new value"); + return EMBER_ZCL_STATUS_SUCCESS; + } - // we either got a toggle, or an on when off, or an off when on, - // so we need to swap the value - newValue = !currentValue; - emberAfOnOffClusterPrintln("Toggle on/off from %x to %x", currentValue, newValue); + // we either got a toggle, or an on when off, or an off when on, + // so we need to swap the value + newValue = !currentValue; + emberAfOnOffClusterPrintln("Toggle on/off from %x to %x", currentValue, newValue); - // the sequence of updating on/off attribute and kick off level change effect should - // be depend on whether we are turning on or off. If we are turning on the light, we - // should update the on/off attribute before kicking off level change, if we are - // turning off the light, we should do the opposite, that is kick off level change - // before updating the on/off attribute. - if (newValue) { - // write the new on/off value - status = emberAfWriteAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)&newValue, - ZCL_BOOLEAN_ATTRIBUTE_TYPE); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); - return status; - } + // the sequence of updating on/off attribute and kick off level change effect should + // be depend on whether we are turning on or off. If we are turning on the light, we + // should update the on/off attribute before kicking off level change, if we are + // turning off the light, we should do the opposite, that is kick off level change + // before updating the on/off attribute. + if (newValue) + { + // write the new on/off value + status = emberAfWriteAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + (uint8_t *) &newValue, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); + return status; + } - // If initiatedByLevelChange is false, then we assume that the level change - // ZCL stuff has not happened and we do it here - if (!initiatedByLevelChange - && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) { - emberAfOnOffClusterLevelControlEffectCallback(endpoint, - newValue); - } - } else { - // If initiatedByLevelChange is false, then we assume that the level change - // ZCL stuff has not happened and we do it here - if (!initiatedByLevelChange - && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) { - emberAfOnOffClusterLevelControlEffectCallback(endpoint, - newValue); + // If initiatedByLevelChange is false, then we assume that the level change + // ZCL stuff has not happened and we do it here + if (!initiatedByLevelChange && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) + { + emberAfOnOffClusterLevelControlEffectCallback(endpoint, newValue); + } } + else + { + // If initiatedByLevelChange is false, then we assume that the level change + // ZCL stuff has not happened and we do it here + if (!initiatedByLevelChange && emberAfContainsServer(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID)) + { + emberAfOnOffClusterLevelControlEffectCallback(endpoint, newValue); + } - // write the new on/off value - status = emberAfWriteAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)&newValue, - ZCL_BOOLEAN_ATTRIBUTE_TYPE); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); - return status; + // write the new on/off value + status = emberAfWriteAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + (uint8_t *) &newValue, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + emberAfOnOffClusterPrintln("ERR: writing on/off %x", status); + return status; + } } - } #ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER - if (initiatedByLevelChange) { - emberAfPluginZllOnOffServerLevelControlZllExtensions(endpoint); - } + if (initiatedByLevelChange) + { + emberAfPluginZllOnOffServerLevelControlZllExtensions(endpoint); + } #endif - // the scene has been changed (the value of on/off has changed) so - // the current scene as descibed in the attribute table is invalid, - // so mark it as invalid (just writes the valid/invalid attribute) - if (emberAfContainsServer(endpoint, ZCL_SCENES_CLUSTER_ID)) { - emberAfScenesClusterMakeInvalidCallback(endpoint); - } + // the scene has been changed (the value of on/off has changed) so + // the current scene as descibed in the attribute table is invalid, + // so mark it as invalid (just writes the valid/invalid attribute) + if (emberAfContainsServer(endpoint, ZCL_SCENES_CLUSTER_ID)) + { + emberAfScenesClusterMakeInvalidCallback(endpoint); + } - // The returned status is based solely on the On/Off cluster. Errors in the - // Level Control and/or Scenes cluster are ignored. - return EMBER_ZCL_STATUS_SUCCESS; + // The returned status is based solely on the On/Off cluster. Errors in the + // Level Control and/or Scenes cluster are ignored. + return EMBER_ZCL_STATUS_SUCCESS; } bool emberAfOnOffClusterOffCallback(void) { - EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), - ZCL_OFF_COMMAND_ID, - false); + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), ZCL_OFF_COMMAND_ID, false); #ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER - if (status == EMBER_ZCL_STATUS_SUCCESS) { - emberAfPluginZllOnOffServerOffZllExtensions(emberAfCurrentCommand()); - } + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + emberAfPluginZllOnOffServerOffZllExtensions(emberAfCurrentCommand()); + } #endif - emberAfSendImmediateDefaultResponse(status); - return true; + emberAfSendImmediateDefaultResponse(status); + return true; } bool emberAfOnOffClusterOnCallback(void) { - EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), - ZCL_ON_COMMAND_ID, - false); + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), ZCL_ON_COMMAND_ID, false); #ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER - if (status == EMBER_ZCL_STATUS_SUCCESS) { - emberAfPluginZllOnOffServerOnZllExtensions(emberAfCurrentCommand()); - } + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + emberAfPluginZllOnOffServerOnZllExtensions(emberAfCurrentCommand()); + } #endif - emberAfSendImmediateDefaultResponse(status); - return true; + emberAfSendImmediateDefaultResponse(status); + return true; } bool emberAfOnOffClusterToggleCallback(void) { - EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), - ZCL_TOGGLE_COMMAND_ID, - false); + EmberAfStatus status = emberAfOnOffClusterSetValueCallback(emberAfCurrentEndpoint(), ZCL_TOGGLE_COMMAND_ID, false); #ifdef EMBER_AF_PLUGIN_ZLL_ON_OFF_SERVER - if (status == EMBER_ZCL_STATUS_SUCCESS) { - emberAfPluginZllOnOffServerToggleZllExtensions(emberAfCurrentCommand()); - } + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + emberAfPluginZllOnOffServerToggleZllExtensions(emberAfCurrentCommand()); + } #endif - emberAfSendImmediateDefaultResponse(status); - return true; + emberAfSendImmediateDefaultResponse(status); + return true; } void emberAfOnOffClusterServerInitCallback(uint8_t endpoint) { #ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE - // StartUp behavior relies on OnOff and StartUpOnOff attributes being tokenized. - if (areStartUpOnOffServerAttributesTokenized(endpoint)) { - // Read the StartUpOnOff attribute and set the OnOff attribute as per - // following from zcl 7 14-0127-20i-zcl-ch-3-general.doc. - // 3.8.2.2.5 StartUpOnOff Attribute - // The StartUpOnOff attribute SHALL define the desired startup behavior of a - // lamp device when it is supplied with power and this state SHALL be - // reflected in the OnOff attribute. The values of the StartUpOnOff - // attribute are listed below. - // Table 3 46. Values of the StartUpOnOff Attribute - // Value Action on power up - // 0x00 Set the OnOff attribute to 0 (off). - // 0x01 Set the OnOff attribute to 1 (on). - // 0x02 If the previous value of the OnOff attribute is equal to 0, - // set the OnOff attribute to 1.If the previous value of the OnOff - // attribute is equal to 1, set the OnOff attribute to 0 (toggle). - // 0x03-0xfe These values are reserved. No action. - // 0xff Set the OnOff attribute to its previous value. + // StartUp behavior relies on OnOff and StartUpOnOff attributes being tokenized. + if (areStartUpOnOffServerAttributesTokenized(endpoint)) + { + // Read the StartUpOnOff attribute and set the OnOff attribute as per + // following from zcl 7 14-0127-20i-zcl-ch-3-general.doc. + // 3.8.2.2.5 StartUpOnOff Attribute + // The StartUpOnOff attribute SHALL define the desired startup behavior of a + // lamp device when it is supplied with power and this state SHALL be + // reflected in the OnOff attribute. The values of the StartUpOnOff + // attribute are listed below. + // Table 3 46. Values of the StartUpOnOff Attribute + // Value Action on power up + // 0x00 Set the OnOff attribute to 0 (off). + // 0x01 Set the OnOff attribute to 1 (on). + // 0x02 If the previous value of the OnOff attribute is equal to 0, + // set the OnOff attribute to 1.If the previous value of the OnOff + // attribute is equal to 1, set the OnOff attribute to 0 (toggle). + // 0x03-0xfe These values are reserved. No action. + // 0xff Set the OnOff attribute to its previous value. - // Initialize startUpOnOff to No action value 0xFE - uint8_t startUpOnOff = 0xFE; - EmberAfStatus status = emberAfReadAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)&startUpOnOff, - sizeof(startUpOnOff), - NULL); - if (status == EMBER_ZCL_STATUS_SUCCESS) { - // Initialise updated value to 0 - bool updatedOnOff = 0; - status = emberAfReadAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)&updatedOnOff, - sizeof(updatedOnOff), - NULL); - if (status == EMBER_ZCL_STATUS_SUCCESS) { - switch (startUpOnOff) { - case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF: - updatedOnOff = 0; // Off - break; - case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON: - updatedOnOff = 1; //On - break; - case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE: - updatedOnOff = !updatedOnOff; - break; - case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS: - default: - // All other values 0x03- 0xFE are reserved - no action. - // When value is 0xFF - update with last value - that is as good as - // no action. - break; + // Initialize startUpOnOff to No action value 0xFE + uint8_t startUpOnOff = 0xFE; + EmberAfStatus status = emberAfReadAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, (uint8_t *) &startUpOnOff, sizeof(startUpOnOff), NULL); + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + // Initialise updated value to 0 + bool updatedOnOff = 0; + status = emberAfReadAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + (uint8_t *) &updatedOnOff, sizeof(updatedOnOff), NULL); + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + switch (startUpOnOff) + { + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_OFF: + updatedOnOff = 0; // Off + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_ON: + updatedOnOff = 1; // On + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_TOGGLE: + updatedOnOff = !updatedOnOff; + break; + case EMBER_ZCL_START_UP_ON_OFF_VALUE_SET_TO_PREVIOUS: + default: + // All other values 0x03- 0xFE are reserved - no action. + // When value is 0xFF - update with last value - that is as good as + // no action. + break; + } + status = emberAfWriteAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + (uint8_t *) &updatedOnOff, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + } } - status = emberAfWriteAttribute(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - (uint8_t *)&updatedOnOff, - ZCL_BOOLEAN_ATTRIBUTE_TYPE); - } } - } #endif - emberAfPluginOnOffClusterServerPostInitCallback(endpoint); + emberAfPluginOnOffClusterServerPostInitCallback(endpoint); } #ifdef ZCL_USING_ON_OFF_CLUSTER_START_UP_ON_OFF_ATTRIBUTE static bool areStartUpOnOffServerAttributesTokenized(uint8_t endpoint) { - EmberAfAttributeMetadata *metadata; + EmberAfAttributeMetadata * metadata; - metadata = emberAfLocateAttributeMetadata(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - EMBER_AF_NULL_MANUFACTURER_CODE); - if (!emberAfAttributeIsTokenized(metadata)) { - return false; - } + metadata = emberAfLocateAttributeMetadata(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, CLUSTER_MASK_SERVER, + EMBER_AF_NULL_MANUFACTURER_CODE); + if (!emberAfAttributeIsTokenized(metadata)) + { + return false; + } - metadata = emberAfLocateAttributeMetadata(endpoint, - ZCL_ON_OFF_CLUSTER_ID, - ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, - CLUSTER_MASK_SERVER, - EMBER_AF_NULL_MANUFACTURER_CODE); - if (!emberAfAttributeIsTokenized(metadata)) { - return false; - } + metadata = emberAfLocateAttributeMetadata(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_START_UP_ON_OFF_ATTRIBUTE_ID, + CLUSTER_MASK_SERVER, EMBER_AF_NULL_MANUFACTURER_CODE); + if (!emberAfAttributeIsTokenized(metadata)) + { + return false; + } - return true; + return true; } #endif diff --git a/examples/wifi-echo/server/esp32/main/process-cluster-message.c b/examples/wifi-echo/server/esp32/main/process-cluster-message.c index 566f34ed0ff288..21444a2faccc2b 100644 --- a/examples/wifi-echo/server/esp32/main/process-cluster-message.c +++ b/examples/wifi-echo/server/esp32/main/process-cluster-message.c @@ -31,12 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains a function that processes cluster-specific - * ZCL message. + * @brief This file contains a function that processes + *cluster-specific ZCL message. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ // this file contains all the common includes for clusters in the zcl-util #include "common.h" @@ -46,68 +47,66 @@ // the EM260 host needs to include the config file #ifdef EZSP_HOST - #include "config.h" +#include "config.h" #endif //------------------------------------------------------------------------------ // Forward Declarations -EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand *cmd); +EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd); //------------------------------------------------------------------------------ -bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand *cmd) +bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand * cmd) { - EmberAfStatus status; + EmberAfStatus status; - // if we are disabled then we can only respond to read or write commands - // or identify cluster (see device enabled attr of basic cluster) - if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) - && cmd->apsFrame->clusterId != ZCL_IDENTIFY_CLUSTER_ID) { - emberAfCorePrintln("%pd, dropping ep 0x%x clus 0x%2x cmd 0x%x", - "disable", - cmd->apsFrame->destinationEndpoint, - cmd->apsFrame->clusterId, - cmd->commandId); - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); - return true; - } + // if we are disabled then we can only respond to read or write commands + // or identify cluster (see device enabled attr of basic cluster) + if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) && cmd->apsFrame->clusterId != ZCL_IDENTIFY_CLUSTER_ID) + { + emberAfCorePrintln("%pd, dropping ep 0x%x clus 0x%2x cmd 0x%x", "disable", cmd->apsFrame->destinationEndpoint, + cmd->apsFrame->clusterId, cmd->commandId); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); + return true; + } #ifdef ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_CLIENT - if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID - && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT - && emberAfKeyEstablishmentClusterClientCommandReceivedCallback(cmd)) { - return true; - } + if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT && + emberAfKeyEstablishmentClusterClientCommandReceivedCallback(cmd)) + { + return true; + } #endif #ifdef ZCL_USING_KEY_ESTABLISHMENT_CLUSTER_SERVER - if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID - && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER - && emberAfKeyEstablishmentClusterServerCommandReceivedCallback(cmd)) { - return true; - } + if (cmd->apsFrame->clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER && + emberAfKeyEstablishmentClusterServerCommandReceivedCallback(cmd)) + { + return true; + } #endif #ifdef ZCL_USING_OTA_BOOTLOAD_CLUSTER_CLIENT - if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID - && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT - && emberAfOtaClientIncomingMessageRawCallback(cmd)) { - return true; - } + if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID && cmd->direction == ZCL_DIRECTION_SERVER_TO_CLIENT && + emberAfOtaClientIncomingMessageRawCallback(cmd)) + { + return true; + } #endif #ifdef ZCL_USING_OTA_BOOTLOAD_CLUSTER_SERVER - if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID - && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER - && emberAfOtaServerIncomingMessageRawCallback(cmd)) { - return true; - } + if (cmd->apsFrame->clusterId == ZCL_OTA_BOOTLOAD_CLUSTER_ID && cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER && + emberAfOtaServerIncomingMessageRawCallback(cmd)) + { + return true; + } #endif - // Pass the command to the generated command parser for processing - status = emberAfClusterSpecificCommandParse(cmd); - if (status != EMBER_ZCL_STATUS_SUCCESS) { - emberAfSendDefaultResponse(cmd, status); - } + // Pass the command to the generated command parser for processing + status = emberAfClusterSpecificCommandParse(cmd); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + emberAfSendDefaultResponse(cmd, status); + } - return true; + return true; } diff --git a/examples/wifi-echo/server/esp32/main/process-global-message.c b/examples/wifi-echo/server/esp32/main/process-global-message.c index d1b14e3cb8cc93..642fd1c34a4651 100644 --- a/examples/wifi-echo/server/esp32/main/process-global-message.c +++ b/examples/wifi-echo/server/esp32/main/process-global-message.c @@ -31,11 +31,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains function that processes global ZCL message. + * @brief This file contains function that processes + *global ZCL message. ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #include "af.h" #include "common.h" @@ -51,7 +53,7 @@ #include "gen/znet-bookkeeping.h" // emAfRetrieveAttributeAndCraftResponse #ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ - #include "app/framework/plugin/comms-hub-function-sub-ghz/comms-hub-function-sub-ghz.h" +#include "app/framework/plugin/comms-hub-function-sub-ghz/comms-hub-function-sub-ghz.h" #endif // flag to keep track of the fact that we just sent a read attr for time and @@ -64,253 +66,235 @@ bool emAfSyncingTime = false; // is that the decision is based on the cluster and attribute IDs requested. // To reduce the possibility of false positives, we disable default response // only for responses containing at least the specified minimum of attributes. -#define MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE 3 +#define MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE 3 #endif -#define DISC_ATTR_RSP_MAX_ATTRIBUTES \ - (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ - - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ - - 1) /* discovery is complete boolean */ \ - / 3) /* size of one discover attributes response entry */ \ - % UINT8_MAX) /* make count fit in an 8 bit integer */ -#define DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES \ - (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH \ - - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ - - 1) /* discovery is complete boolean */ \ - / 4) /* size of one discover attributes extended response entry */ \ - % UINT8_MAX) /* make count fit in an 8 bit integer */ +#define DISC_ATTR_RSP_MAX_ATTRIBUTES \ + (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ + - 1) /* discovery is complete boolean */ \ + / 3) /* size of one discover attributes response entry */ \ + % UINT8_MAX) /* make count fit in an 8 bit integer */ +#define DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES \ + (((EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH - EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD /* max ZCL header size */ \ + - 1) /* discovery is complete boolean */ \ + / 4) /* size of one discover attributes extended response entry */ \ + % UINT8_MAX) /* make count fit in an 8 bit integer */ #if defined(EMBER_AF_SUPPORT_COMMAND_DISCOVERY) -static void printDiscoverCommandsResponse(bool generated, - uint16_t clusterId, - bool discoveryComplete, - uint8_t* buffer, +static void printDiscoverCommandsResponse(bool generated, uint16_t clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t length) { - uint16_t i; - emberAfServiceDiscoveryPrint("Discover Commands response (complete: %c), %p IDs: ", - (discoveryComplete - ? 'y' - : 'n'), - (generated - ? "Generated" - : "Received")); - for (i = 0; i < length; i++) { - emberAfServiceDiscoveryPrint("0x%X ", buffer[i]); - } - emberAfServiceDiscoveryPrintln(""); + uint16_t i; + emberAfServiceDiscoveryPrint("Discover Commands response (complete: %c), %p IDs: ", (discoveryComplete ? 'y' : 'n'), + (generated ? "Generated" : "Received")); + for (i = 0; i < length; i++) + { + emberAfServiceDiscoveryPrint("0x%X ", buffer[i]); + } + emberAfServiceDiscoveryPrintln(""); } #endif -bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd) +bool emAfProcessGlobalCommand(EmberAfClusterCommand * cmd) { - uint16_t attrId; - uint8_t frameControl; - // This is a little clumsy but easier to read and port - // from earlier implementation. - EmberAfClusterId clusterId = cmd->apsFrame->clusterId; - uint8_t zclCmd = cmd->commandId; - uint8_t *message = cmd->buffer; - uint16_t msgLen = cmd->bufLen; - uint16_t msgIndex = cmd->payloadStartIndex; - uint8_t clientServerMask = (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER - ? CLUSTER_MASK_SERVER - : CLUSTER_MASK_CLIENT); - - // If we are disabled then we can only respond to read or write commands - // or identify cluster (see device enabled attr of basic cluster) - if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) - && zclCmd != ZCL_READ_ATTRIBUTES_COMMAND_ID - && zclCmd != ZCL_WRITE_ATTRIBUTES_COMMAND_ID - && zclCmd != ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID - && zclCmd != ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID - && clusterId != ZCL_IDENTIFY_CLUSTER_ID) { - emberAfCorePrintln("disabled"); - emberAfDebugPrintln("%pd, dropping global cmd:%x", "disable", zclCmd); - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); - return true; - } - - // If a manufacturer-specific command arrives using our special internal "not - // manufacturer specific" code, we need to reject it outright without letting - // it pass through to the rest of the code. The internal read and write APIs - // would interpret it as a standard attribute or cluster and return incorrect - // results. - if (cmd->mfgSpecific && cmd->mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) { - goto kickout; - } - - // Clear out the response buffer by setting its length to zero - appResponseLength = 0; - - // Make the ZCL header for the response - // note: cmd byte is set below - frameControl = (ZCL_GLOBAL_COMMAND - | (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER - ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT - | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES - : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER - | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES)); - if (cmd->mfgSpecific) { - frameControl |= ZCL_MANUFACTURER_SPECIFIC_MASK; - } - emberAfPutInt8uInResp(frameControl); - if (cmd->mfgSpecific) { - emberAfPutInt16uInResp(cmd->mfgCode); - } - emberAfPutInt8uInResp(cmd->seqNum); - - switch (zclCmd) { + uint16_t attrId; + uint8_t frameControl; + // This is a little clumsy but easier to read and port + // from earlier implementation. + EmberAfClusterId clusterId = cmd->apsFrame->clusterId; + uint8_t zclCmd = cmd->commandId; + uint8_t * message = cmd->buffer; + uint16_t msgLen = cmd->bufLen; + uint16_t msgIndex = cmd->payloadStartIndex; + uint8_t clientServerMask = (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER ? CLUSTER_MASK_SERVER : CLUSTER_MASK_CLIENT); + + // If we are disabled then we can only respond to read or write commands + // or identify cluster (see device enabled attr of basic cluster) + if (!emberAfIsDeviceEnabled(cmd->apsFrame->destinationEndpoint) && zclCmd != ZCL_READ_ATTRIBUTES_COMMAND_ID && + zclCmd != ZCL_WRITE_ATTRIBUTES_COMMAND_ID && zclCmd != ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID && + zclCmd != ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID && clusterId != ZCL_IDENTIFY_CLUSTER_ID) + { + emberAfCorePrintln("disabled"); + emberAfDebugPrintln("%pd, dropping global cmd:%x", "disable", zclCmd); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_FAILURE); + return true; + } + + // If a manufacturer-specific command arrives using our special internal "not + // manufacturer specific" code, we need to reject it outright without letting + // it pass through to the rest of the code. The internal read and write APIs + // would interpret it as a standard attribute or cluster and return incorrect + // results. + if (cmd->mfgSpecific && cmd->mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE) + { + goto kickout; + } + + // Clear out the response buffer by setting its length to zero + appResponseLength = 0; + + // Make the ZCL header for the response + // note: cmd byte is set below + frameControl = (ZCL_GLOBAL_COMMAND | + (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER + ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES + : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER | EMBER_AF_DEFAULT_RESPONSE_POLICY_RESPONSES)); + if (cmd->mfgSpecific) + { + frameControl |= ZCL_MANUFACTURER_SPECIFIC_MASK; + } + emberAfPutInt8uInResp(frameControl); + if (cmd->mfgSpecific) + { + emberAfPutInt16uInResp(cmd->mfgCode); + } + emberAfPutInt8uInResp(cmd->seqNum); + + switch (zclCmd) + { // The format of the read attributes cmd is: // ([attr ID:2]) * N // The format of the read attributes response is: // ([attr ID:2] [status:1] [data type:0/1] [data:0/N]) * N - case ZCL_READ_ATTRIBUTES_COMMAND_ID: - { - emberAfAttributesPrintln("%p: clus %2x", "READ_ATTR", clusterId); - // Set the cmd byte - this is byte 3 index 2, but since we have - // already incremented past the 3 byte ZCL header (our index is at 3), - // this gets written to "-1" since 3 - 1 = 2. - emberAfPutInt8uInResp(ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID); - - // This message contains N 2-byte attr IDs after the 3 byte ZCL header, - // for each one we need to look it up and make a response - while (msgIndex + 2 <= msgLen) { - // Get the attribute ID and store it in the response buffer - // least significant byte is first OTA - attrId = emberAfGetInt16u(message, msgIndex, msgLen); + case ZCL_READ_ATTRIBUTES_COMMAND_ID: { + emberAfAttributesPrintln("%p: clus %2x", "READ_ATTR", clusterId); + // Set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp(ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID); + + // This message contains N 2-byte attr IDs after the 3 byte ZCL header, + // for each one we need to look it up and make a response + while (msgIndex + 2 <= msgLen) + { + // Get the attribute ID and store it in the response buffer + // least significant byte is first OTA + attrId = emberAfGetInt16u(message, msgIndex, msgLen); #ifdef EMBER_AF_GBCS_COMPATIBLE - // GBCS explicitly lists some commands that need to be sent with "disable - // default response" flag set, including some ReadAttributes responses. - // We make it conditional on GBCS so it does not affect standard SE apps. - { - static const struct { - EmberAfClusterId clusterId; - uint16_t attrId; - } noDefaultResponseSet[] = { - { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID }, - { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID }, - { ZCL_PRICE_CLUSTER_ID, ZCL_STANDING_CHARGE_ATTRIBUTE_ID }, - { ZCL_PRICE_CLUSTER_ID, ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID }, - { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID }, - { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_MULTIPLIER_ATTRIBUTE_ID }, - { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_DIVISOR_ATTRIBUTE_ID }, - }; - uint8_t i; - uint8_t foundMatchingAttrIdsCount = 0; - - for (i = 0; i < sizeof noDefaultResponseSet / sizeof noDefaultResponseSet[0]; ++i) { - if (noDefaultResponseSet[i].clusterId == clusterId - && noDefaultResponseSet[i].attrId == attrId) { - if (++foundMatchingAttrIdsCount >= MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE) { - emberAfSetDisableDefaultResponse(EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT); - break; - } + // GBCS explicitly lists some commands that need to be sent with "disable + // default response" flag set, including some ReadAttributes responses. + // We make it conditional on GBCS so it does not affect standard SE apps. + { + static const struct + { + EmberAfClusterId clusterId; + uint16_t attrId; + } noDefaultResponseSet[] = { + { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_MULTIPLIER_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_THRESHOLD_DIVISOR_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_STANDING_CHARGE_ATTRIBUTE_ID }, + { ZCL_PRICE_CLUSTER_ID, ZCL_TARIFF_UNIT_OF_MEASURE_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_UNIT_OF_MEASURE_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_MULTIPLIER_ATTRIBUTE_ID }, + { ZCL_SIMPLE_METERING_CLUSTER_ID, ZCL_DIVISOR_ATTRIBUTE_ID }, + }; + uint8_t i; + uint8_t foundMatchingAttrIdsCount = 0; + + for (i = 0; i < sizeof noDefaultResponseSet / sizeof noDefaultResponseSet[0]; ++i) + { + if (noDefaultResponseSet[i].clusterId == clusterId && noDefaultResponseSet[i].attrId == attrId) + { + if (++foundMatchingAttrIdsCount >= MIN_MATCHING_ATTR_IDS_TO_DISABLE_DEFAULT_RESPONSE) + { + emberAfSetDisableDefaultResponse(EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT); + break; + } + } + } } - } - } - #ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ - // This plugin sets channel change notification flags and needs to know - // when those flags have been read. - if (clientServerMask == CLUSTER_MASK_SERVER) { - emAfCommsHubFunctionSubGhzReadAttributeNotification(cmd->source, - clusterId, - attrId); - } - #endif +#ifdef EMBER_AF_PLUGIN_COMMS_HUB_FUNCTION_SUB_GHZ + // This plugin sets channel change notification flags and needs to know + // when those flags have been read. + if (clientServerMask == CLUSTER_MASK_SERVER) + { + emAfCommsHubFunctionSubGhzReadAttributeNotification(cmd->source, clusterId, attrId); + } +#endif #endif - // This function reads the attribute and creates the correct response - // in the response buffer - if (!emAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, - clusterId, - attrId, - clientServerMask, - cmd->mfgCode, - (EMBER_AF_RESPONSE_BUFFER_LEN - - appResponseLength))) { - emberAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, - clusterId, - attrId, - clientServerMask, - cmd->mfgCode, - (EMBER_AF_RESPONSE_BUFFER_LEN - - appResponseLength)); - } + // This function reads the attribute and creates the correct response + // in the response buffer + if (!emAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask, + cmd->mfgCode, (EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength))) + { + emberAfRetrieveAttributeAndCraftResponse(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask, + cmd->mfgCode, (EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength)); + } - // Go to next attrID - msgIndex += 2; - } + // Go to next attrID + msgIndex += 2; + } } - emberAfSendResponse(); - return true; + emberAfSendResponse(); + return true; // Write undivided means all attributes must be written in order to write // any of them. So first do a check. If the check fails, send back a fail // response. If it works, fall through to the normal write attr code. // write attr responses are the same for undivided and normal writes. - case ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID: - { - uint8_t numFailures = 0; - uint8_t dataType; - uint16_t dataSize; - EmberAfStatus status; - - emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); - - // Go through the message until there are no more attrID/type/data - while (msgIndex < msgLen - 3) { - attrId = emberAfGetInt16u(message, msgIndex, msgLen); - dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); - - dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); - - // Check to see if there are dataSize bytes left in the message if it is a string - if (emberAfIsThisDataTypeAStringType(dataType) - && (dataSize < msgLen - (msgIndex + 3))) { - // This command is malformed - status = EMBER_ZCL_STATUS_MALFORMED_COMMAND; - } else { - status = emberAfVerifyAttributeWrite(cmd->apsFrame->destinationEndpoint, - clusterId, - attrId, - clientServerMask, - cmd->mfgCode, - &(message[msgIndex + 3]), - dataType); - } + case ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID: { + uint8_t numFailures = 0; + uint8_t dataType; + uint16_t dataSize; + EmberAfStatus status; - if (status != EMBER_ZCL_STATUS_SUCCESS) { - numFailures++; - // Write to the response buffer - status and then attrID - emberAfPutInt8uInResp(status); - emberAfPutInt16uInResp(attrId); - - emberAfAttributesPrintln("WRITE: clus %2x attr %2x ", clusterId, attrId); - emberAfAttributesPrintln("FAIL %x", status); - emberAfCoreFlush(); - if (status == EMBER_ZCL_STATUS_MALFORMED_COMMAND) { - // this attribute is malformed, terminate attribute processing. - break; - } - } + emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); - // Increment past the attribute id (two bytes), the type (one byte), and - // the data (N bytes, including the length byte for strings). - msgIndex += 3 + dataSize; - } - // If there are any failures, send the response and exit - if (numFailures > 0) { - emberAfSendResponse(); - return true; - } + // Go through the message until there are no more attrID/type/data + while (msgIndex < msgLen - 3) + { + attrId = emberAfGetInt16u(message, msgIndex, msgLen); + dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); + + dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); + + // Check to see if there are dataSize bytes left in the message if it is a string + if (emberAfIsThisDataTypeAStringType(dataType) && (dataSize < msgLen - (msgIndex + 3))) + { + // This command is malformed + status = EMBER_ZCL_STATUS_MALFORMED_COMMAND; + } + else + { + status = emberAfVerifyAttributeWrite(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask, + cmd->mfgCode, &(message[msgIndex + 3]), dataType); + } + + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + numFailures++; + // Write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + + emberAfAttributesPrintln("WRITE: clus %2x attr %2x ", clusterId, attrId); + emberAfAttributesPrintln("FAIL %x", status); + emberAfCoreFlush(); + if (status == EMBER_ZCL_STATUS_MALFORMED_COMMAND) + { + // this attribute is malformed, terminate attribute processing. + break; + } + } + + // Increment past the attribute id (two bytes), the type (one byte), and + // the data (N bytes, including the length byte for strings). + msgIndex += 3 + dataSize; + } + // If there are any failures, send the response and exit + if (numFailures > 0) + { + emberAfSendResponse(); + return true; + } } - // Reset message back to start - msgIndex = cmd->payloadStartIndex; - appResponseLength = (cmd->mfgSpecific ? 4 : 2); + // Reset message back to start + msgIndex = cmd->payloadStartIndex; + appResponseLength = (cmd->mfgSpecific ? 4 : 2); // DO NOT BREAK from this case // the format of the write attributes cmd is: @@ -321,435 +305,400 @@ bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd) // is sent. write attr no response is handled by just executing the same // code but not setting the flag that sends the response at the end. case ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID: - case ZCL_WRITE_ATTRIBUTES_COMMAND_ID: - { - uint8_t numFailures = 0; - uint8_t numSuccess = 0; - uint8_t dataType; - uint16_t dataSize; + case ZCL_WRITE_ATTRIBUTES_COMMAND_ID: { + uint8_t numFailures = 0; + uint8_t numSuccess = 0; + uint8_t dataType; + uint16_t dataSize; #if (BIGENDIAN_CPU) - uint8_t writeData[ATTRIBUTE_LARGEST]; + uint8_t writeData[ATTRIBUTE_LARGEST]; #endif //(BIGENDIAN_CPU) - EmberAfStatus status; + EmberAfStatus status; - // set the cmd byte - this is byte 3 index 2, but since we have - // already incremented past the 3 byte ZCL header (our index is at 3), - // this gets written to "-1" since 3 - 1 = 2. - emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); + // set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp(ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID); - // go through the message until there are no more attrID/type/data - while (msgLen > msgIndex + 3) { - attrId = emberAfGetInt16u(message, msgIndex, msgLen); - dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); + // go through the message until there are no more attrID/type/data + while (msgLen > msgIndex + 3) + { + attrId = emberAfGetInt16u(message, msgIndex, msgLen); + dataType = emberAfGetInt8u(message, msgIndex + 2, msgLen); - dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); + dataSize = emberAfAttributeValueSize(dataType, message + msgIndex + 3); - // the data is sent little endian over-the-air, it needs to be - // inserted into the table big endian for the EM250 and little - // endian for the EZSP hosts. This means for the EM250 the data - // needs to be reversed before sending to writeAttributes -#if (BIGENDIAN_CPU) - if (dataSize <= msgLen - (msgIndex + 3) && dataSize <= ATTRIBUTE_LARGEST) { - // strings go over the air as length byte and then in human - // readable format. These should not be flipped. - if (emberAfIsThisDataTypeAStringType(dataType)) { - MEMMOVE(writeData, message + msgIndex + 3, dataSize); - } else { // the data is sent little endian over-the-air, it needs to be - // inserted into the table big endian - uint16_t i; - for (i = 0; i < dataSize; i++) { - writeData[i] = message[msgIndex + 3 + dataSize - i - 1]; - } - } -#else //(BIGENDIAN_CPU) - if (dataSize <= msgLen - (msgIndex + 3)) { + // inserted into the table big endian for the EM250 and little + // endian for the EZSP hosts. This means for the EM250 the data + // needs to be reversed before sending to writeAttributes +#if (BIGENDIAN_CPU) + if (dataSize <= msgLen - (msgIndex + 3) && dataSize <= ATTRIBUTE_LARGEST) + { + // strings go over the air as length byte and then in human + // readable format. These should not be flipped. + if (emberAfIsThisDataTypeAStringType(dataType)) + { + MEMMOVE(writeData, message + msgIndex + 3, dataSize); + } + else + { + // the data is sent little endian over-the-air, it needs to be + // inserted into the table big endian + uint16_t i; + for (i = 0; i < dataSize; i++) + { + writeData[i] = message[msgIndex + 3 + dataSize - i - 1]; + } + } +#else //(BIGENDIAN_CPU) + if (dataSize <= msgLen - (msgIndex + 3)) + { #endif //(BIGENDIAN_CPU) - status = emberAfWriteAttributeExternal(cmd->apsFrame->destinationEndpoint, - clusterId, - attrId, - clientServerMask, - cmd->mfgCode, - #if (BIGENDIAN_CPU) - writeData, - #else //(BIGENDIAN_CPU) - &(message[msgIndex + 3]), - #endif //(BIGENDIAN_CPU) - dataType); - emberAfAttributesPrint("WRITE: clus %2x attr %2x ", - clusterId, - attrId); - if (status == EMBER_ZCL_STATUS_SUCCESS) { - numSuccess++; - emberAfAttributesPrintln("OK"); - } else { - numFailures++; - // write to the response buffer - status and then attrID - emberAfPutInt8uInResp(status); - emberAfPutInt16uInResp(attrId); - emberAfAttributesPrintln("FAIL %x", status); - } - emberAfCoreFlush(); - - // Increment past the attribute id (two bytes), the type (one byte), and - // the data (N bytes, including the length byte for strings). - msgIndex += 3 + dataSize; - } else { - numFailures++; - status = EMBER_ZCL_STATUS_INVALID_VALUE; - // write to the response buffer - status and then attrID - emberAfPutInt8uInResp(status); - emberAfPutInt16uInResp(attrId); - emberAfAttributesPrintln("FAIL %x", status); - // size exceeds buffer, terminate loop - break; + status = emberAfWriteAttributeExternal(cmd->apsFrame->destinationEndpoint, clusterId, attrId, clientServerMask, + cmd->mfgCode, +#if (BIGENDIAN_CPU) + writeData, +#else //(BIGENDIAN_CPU) + &(message[msgIndex + 3]), +#endif //(BIGENDIAN_CPU) + dataType); + emberAfAttributesPrint("WRITE: clus %2x attr %2x ", clusterId, attrId); + if (status == EMBER_ZCL_STATUS_SUCCESS) + { + numSuccess++; + emberAfAttributesPrintln("OK"); + } + else + { + numFailures++; + // write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + emberAfAttributesPrintln("FAIL %x", status); + } + emberAfCoreFlush(); + + // Increment past the attribute id (two bytes), the type (one byte), and + // the data (N bytes, including the length byte for strings). + msgIndex += 3 + dataSize; + } + else + { + numFailures++; + status = EMBER_ZCL_STATUS_INVALID_VALUE; + // write to the response buffer - status and then attrID + emberAfPutInt8uInResp(status); + emberAfPutInt16uInResp(attrId); + emberAfAttributesPrintln("FAIL %x", status); + // size exceeds buffer, terminate loop + break; + } } - } - // always send a response unless the cmd requested no response - if (zclCmd == ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID) { - return true; - } - - if (numFailures == 0) { - // if no failures and no success this means the packet was too short - // print an error message but still return true as we consumed the - // message - if (numSuccess == 0) { - emberAfAttributesPrintln("WRITE: too short"); - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_MALFORMED_COMMAND); - return true; + // always send a response unless the cmd requested no response + if (zclCmd == ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID) + { + return true; } - // if no failures and at least one success, write a success status - // that means everything worked - else { - emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); + + if (numFailures == 0) + { + // if no failures and no success this means the packet was too short + // print an error message but still return true as we consumed the + // message + if (numSuccess == 0) + { + emberAfAttributesPrintln("WRITE: too short"); + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_MALFORMED_COMMAND); + return true; + } + // if no failures and at least one success, write a success status + // that means everything worked + else + { + emberAfPutInt8uInResp(EMBER_ZCL_STATUS_SUCCESS); + } } - } - emberAfSendResponse(); - return true; + emberAfSendResponse(); + return true; } // the format of discover is: [start attr ID:2] [max attr IDs:1] // the format of the response is: [done:1] ([attrID:2] [type:1]) * N case ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID: - case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID: - { - EmberAfAttributeId startingAttributeId; - uint8_t numberAttributes; - uint8_t *complete; - - emberAfAttributesPrintln("%p%p: clus %2x", "DISC_ATTR", - (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID ? "_EXT" : ""), - clusterId); - - // set the cmd byte - this is byte 3 index 2, but since we have - // already incremented past the 3 byte ZCL header (our index is at 3), - // this gets written to "-1" since 3 - 1 = 2. - emberAfPutInt8uInResp( - (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID - ? ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID - : ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID)); - - // get the attrId to start on and the max count - startingAttributeId = emberAfGetInt16u(message, msgIndex, msgLen); - numberAttributes = emberAfGetInt8u(message, msgIndex + 2, msgLen); - - // BUGZID: EMAPPFWKV2-828, EMAPPFWKV2-1401 - if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID - && numberAttributes > DISC_ATTR_RSP_MAX_ATTRIBUTES) { - numberAttributes = DISC_ATTR_RSP_MAX_ATTRIBUTES; - } else if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID - && numberAttributes > DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES) { - numberAttributes = DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES; - } else { - // MISRA requires ..else if.. to have terminating else. - } - - // The response has a one-byte field indicating whether discovery is - // complete. We can't populate that field until we've finished going - // through all the attributes, so save a placeholder, write a temporary - // value for now (so that the offset moves forward), and write the real - // value when we're done. - complete = &(appResponseData[appResponseLength]); - emberAfPutInt8uInResp(false); - *complete = emberAfReadSequentialAttributesAddToResponse( - cmd->apsFrame->destinationEndpoint, - clusterId, - startingAttributeId, - clientServerMask, - cmd->mfgCode, - numberAttributes, - (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID)); - emberAfSendResponse(); - return true; + case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID: { + EmberAfAttributeId startingAttributeId; + uint8_t numberAttributes; + uint8_t * complete; + + emberAfAttributesPrintln("%p%p: clus %2x", "DISC_ATTR", + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID ? "_EXT" : ""), clusterId); + + // set the cmd byte - this is byte 3 index 2, but since we have + // already incremented past the 3 byte ZCL header (our index is at 3), + // this gets written to "-1" since 3 - 1 = 2. + emberAfPutInt8uInResp((zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID + ? ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID + : ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID)); + + // get the attrId to start on and the max count + startingAttributeId = emberAfGetInt16u(message, msgIndex, msgLen); + numberAttributes = emberAfGetInt8u(message, msgIndex + 2, msgLen); + + // BUGZID: EMAPPFWKV2-828, EMAPPFWKV2-1401 + if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID && numberAttributes > DISC_ATTR_RSP_MAX_ATTRIBUTES) + { + numberAttributes = DISC_ATTR_RSP_MAX_ATTRIBUTES; + } + else if (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID && numberAttributes > DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES) + { + numberAttributes = DISC_ATTR_EXT_RSP_MAX_ATTRIBUTES; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } + + // The response has a one-byte field indicating whether discovery is + // complete. We can't populate that field until we've finished going + // through all the attributes, so save a placeholder, write a temporary + // value for now (so that the offset moves forward), and write the real + // value when we're done. + complete = &(appResponseData[appResponseLength]); + emberAfPutInt8uInResp(false); + *complete = emberAfReadSequentialAttributesAddToResponse(cmd->apsFrame->destinationEndpoint, clusterId, startingAttributeId, + clientServerMask, cmd->mfgCode, numberAttributes, + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID)); + emberAfSendResponse(); + return true; } case ZCL_CONFIGURE_REPORTING_COMMAND_ID: - if (emberAfConfigureReportingCommandCallback(cmd)) { - return true; - } - break; + if (emberAfConfigureReportingCommandCallback(cmd)) + { + return true; + } + break; case ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID: - if (emberAfReadReportingConfigurationCommandCallback(cmd)) { - return true; - } - break; + if (emberAfReadReportingConfigurationCommandCallback(cmd)) + { + return true; + } + break; // ([attribute id:2] [status:1] [type:0/1] [value:0/V])+ case ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID: - // The "timesync" command in the CLI sends a Read Attributes command for the - // Time attribute on another device and then sets a flag. If that flag is - // set and a Read Attributes Response command for the time comes in, we set - // the time to the value in the message. - if (clusterId == ZCL_TIME_CLUSTER_ID) { - if (emAfSyncingTime - && !cmd->mfgSpecific - && msgLen - msgIndex == 8 // attr:2 status:1 type:1 data:4 - && (emberAfGetInt16u(message, msgIndex, msgLen) - == ZCL_TIME_ATTRIBUTE_ID) - && (emberAfGetInt8u(message, msgIndex + 2, msgLen) - == EMBER_ZCL_STATUS_SUCCESS) - && (emberAfGetInt8u(message, msgIndex + 3, msgLen) - == ZCL_UTC_TIME_ATTRIBUTE_TYPE)) { - // emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen)); - emberAfDebugPrintln("time sync ok, time: %4x", emberAfGetCurrentTime()); - emAfSyncingTime = false; - } + // The "timesync" command in the CLI sends a Read Attributes command for the + // Time attribute on another device and then sets a flag. If that flag is + // set and a Read Attributes Response command for the time comes in, we set + // the time to the value in the message. + if (clusterId == ZCL_TIME_CLUSTER_ID) + { + if (emAfSyncingTime && !cmd->mfgSpecific && msgLen - msgIndex == 8 // attr:2 status:1 type:1 data:4 + && (emberAfGetInt16u(message, msgIndex, msgLen) == ZCL_TIME_ATTRIBUTE_ID) && + (emberAfGetInt8u(message, msgIndex + 2, msgLen) == EMBER_ZCL_STATUS_SUCCESS) && + (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_UTC_TIME_ATTRIBUTE_TYPE)) + { + // emberAfSetTime(emberAfGetInt32u(message, msgIndex + 4, msgLen)); + emberAfDebugPrintln("time sync ok, time: %4x", emberAfGetCurrentTime()); + emAfSyncingTime = false; + } #ifdef EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED - emAfPluginSmartEnergyRegistrationReadAttributesResponseCallback(message + msgIndex, - msgLen - msgIndex); -#endif //EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED + emAfPluginSmartEnergyRegistrationReadAttributesResponseCallback(message + msgIndex, msgLen - msgIndex); +#endif // EMBER_AF_PLUGIN_SMART_ENERGY_REGISTRATION_TIME_SOURCE_REQUIRED #ifdef EMBER_AF_PLUGIN_WWAH_SERVER_SILABS - emAfPluginSlWwahReadAttributesResponseCallback(clusterId, message, msgLen); + emAfPluginSlWwahReadAttributesResponseCallback(clusterId, message, msgLen); #endif - } + } #ifdef EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE - if (clusterId == ZCL_KEEPALIVE_CLUSTER_ID - && !cmd->mfgSpecific) { - emAfPluginTrustCenterKeepaliveReadAttributesResponseCallback(message + msgIndex, - msgLen - msgIndex); - } -#endif //EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE + if (clusterId == ZCL_KEEPALIVE_CLUSTER_ID && !cmd->mfgSpecific) + { + emAfPluginTrustCenterKeepaliveReadAttributesResponseCallback(message + msgIndex, msgLen - msgIndex); + } +#endif // EMBER_AF_PLUGIN_TRUST_CENTER_KEEPALIVE #if defined(EMBER_AF_PLUGIN_KEY_ESTABLISHMENT) - if (clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID - && !cmd->mfgSpecific - && msgLen - msgIndex == 6 //attr:2 status:1 type:1 data:2 - && (emberAfGetInt16u(message, msgIndex, msgLen) - == ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID) - && (emberAfGetInt8u(message, msgIndex + 2, msgLen) - == EMBER_ZCL_STATUS_SUCCESS) - && ((emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_ENUM16_ATTRIBUTE_TYPE) - || (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_BITMAP16_ATTRIBUTE_TYPE))) { - uint16_t suite = emberAfGetInt16u(message, msgIndex + 4, msgLen); - emberAfPluginKeyEstablishmentReadAttributesCallback(suite); - } + if (clusterId == ZCL_KEY_ESTABLISHMENT_CLUSTER_ID && !cmd->mfgSpecific && + msgLen - msgIndex == 6 // attr:2 status:1 type:1 data:2 + && (emberAfGetInt16u(message, msgIndex, msgLen) == ZCL_KEY_ESTABLISHMENT_SUITE_CLIENT_ATTRIBUTE_ID) && + (emberAfGetInt8u(message, msgIndex + 2, msgLen) == EMBER_ZCL_STATUS_SUCCESS) && + ((emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_ENUM16_ATTRIBUTE_TYPE) || + (emberAfGetInt8u(message, msgIndex + 3, msgLen) == ZCL_BITMAP16_ATTRIBUTE_TYPE))) + { + uint16_t suite = emberAfGetInt16u(message, msgIndex + 4, msgLen); + emberAfPluginKeyEstablishmentReadAttributesCallback(suite); + } #endif #if defined(EMBER_AF_PLUGIN_TEST_HARNESS) - emberAfPluginTestHarnessReadAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex); + emberAfPluginTestHarnessReadAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex); #endif #if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT) - emberAfPluginIasZoneClientReadAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex); + emberAfPluginIasZoneClientReadAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex); #endif #if defined(EMBER_AF_PLUGIN_SIMPLE_METERING_SERVER) - emberAfPluginSimpleMeteringClusterReadAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex); + emberAfPluginSimpleMeteringClusterReadAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex); #endif - if (!emAfReadAttributesResponse(clusterId, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; + if (!emAfReadAttributesResponse(clusterId, message + msgIndex, msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; // ([status:1] [attribute id:2])+ case ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID: - #if defined(EMBER_AF_PLUGIN_TEST_HARNESS) - emberAfPluginTestHarnessWriteAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex); - #endif - - #if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT) - emberAfPluginIasZoneClientWriteAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex); - #endif - - if (!emberAfWriteAttributesResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; +#if defined(EMBER_AF_PLUGIN_TEST_HARNESS) + emberAfPluginTestHarnessWriteAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex); +#endif + +#if defined(EMBER_AF_PLUGIN_IAS_ZONE_CLIENT) + emberAfPluginIasZoneClientWriteAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex); +#endif + + if (!emberAfWriteAttributesResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; // ([status:1] [direction:1] [attribute id:2])+ case ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID: - if (!emberAfConfigureReportingResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; + if (!emberAfConfigureReportingResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; // ([status:1] [direction:1] [attribute id:2] [type:0/1] ... // ... [min interval:0/2] [max interval:0/2] [reportable change:0/V] ... // ... [timeout:0/2])+ case ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID: - if (!emberAfReadReportingConfigurationResponseCallback(clusterId, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; + if (!emberAfReadReportingConfigurationResponseCallback(clusterId, message + msgIndex, msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; // ([attribute id:2] [type:1] [data:V])+ case ZCL_REPORT_ATTRIBUTES_COMMAND_ID: - if (!emAfReportAttributes(clusterId, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; + if (!emAfReportAttributes(clusterId, message + msgIndex, msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; // [command id:1] [status:1] - case ZCL_DEFAULT_RESPONSE_COMMAND_ID: - { - EmberAfStatus status; - uint8_t commandId; - commandId = emberAfGetInt8u(message, msgIndex, msgLen); - msgIndex++; - status = (EmberAfStatus)emberAfGetInt8u(message, msgIndex, msgLen); - - emberAfClusterDefaultResponseWithMfgCodeCallback(cmd->apsFrame->destinationEndpoint, - clusterId, - commandId, - status, - clientServerMask, - cmd->mfgCode); - emberAfDefaultResponseCallback(clusterId, commandId, status); - return true; + case ZCL_DEFAULT_RESPONSE_COMMAND_ID: { + EmberAfStatus status; + uint8_t commandId; + commandId = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + status = (EmberAfStatus) emberAfGetInt8u(message, msgIndex, msgLen); + + emberAfClusterDefaultResponseWithMfgCodeCallback(cmd->apsFrame->destinationEndpoint, clusterId, commandId, status, + clientServerMask, cmd->mfgCode); + emberAfDefaultResponseCallback(clusterId, commandId, status); + return true; } // [discovery complete:1] ([attribute id:2] [type:1])* case ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID: - case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID: - { - bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); - msgIndex++; - if (!emberAfDiscoverAttributesResponseCallback(clusterId, - discoveryComplete, - message + msgIndex, - msgLen - msgIndex, - (zclCmd - == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID))) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); - } - return true; + case ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID: { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if (!emberAfDiscoverAttributesResponseCallback(clusterId, discoveryComplete, message + msgIndex, msgLen - msgIndex, + (zclCmd == ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID))) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; } #ifdef EMBER_AF_SUPPORT_COMMAND_DISCOVERY // Command discovery takes a bit of flash because we need to add structs // for commands into the generated hader. Hence it's all configurable. case ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID: - case ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID: - { - uint8_t startCommandIdentifier = emberAfGetInt8u(message, msgIndex, msgLen); - uint8_t maximumCommandIdentifiers = emberAfGetInt8u(message, msgIndex + 1, msgLen); - uint16_t savedIndex; - bool flag; - - // Ok. This is the command that matters. - if ( zclCmd == ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID ) { - emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID); - flag = false; - } else { - emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID); - flag = true; - } - savedIndex = appResponseLength; - flag = emberAfExtractCommandIds(flag, - cmd, - clusterId, - appResponseData + appResponseLength + 1, - EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength - 1, - &appResponseLength, - startCommandIdentifier, - maximumCommandIdentifiers); - appResponseData[savedIndex] = (flag ? 1 : 0); - appResponseLength++; - emberAfSendResponse(); - return true; - } - case ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID: - { - bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); - msgIndex++; - if ( msgIndex <= msgLen ) { - printDiscoverCommandsResponse(false, // is ZCL command generated? - clusterId, - discoveryComplete, - message + msgIndex, - msgLen - msgIndex); - if (!emberAfDiscoverCommandsReceivedResponseCallback(clusterId, - cmd->mfgCode, - discoveryComplete, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + case ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID: { + uint8_t startCommandIdentifier = emberAfGetInt8u(message, msgIndex, msgLen); + uint8_t maximumCommandIdentifiers = emberAfGetInt8u(message, msgIndex + 1, msgLen); + uint16_t savedIndex; + bool flag; + + // Ok. This is the command that matters. + if (zclCmd == ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID) + { + emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID); + flag = false; + } + else + { + emberAfPutInt8uInResp(ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID); + flag = true; } + savedIndex = appResponseLength; + flag = emberAfExtractCommandIds(flag, cmd, clusterId, appResponseData + appResponseLength + 1, + EMBER_AF_RESPONSE_BUFFER_LEN - appResponseLength - 1, &appResponseLength, + startCommandIdentifier, maximumCommandIdentifiers); + appResponseData[savedIndex] = (flag ? 1 : 0); + appResponseLength++; + emberAfSendResponse(); return true; - } else { - return false; - } } - case ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID: - { - bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); - msgIndex++; - if ( msgIndex <= msgLen ) { - printDiscoverCommandsResponse(true, // is ZCL command generated? - clusterId, - discoveryComplete, - message + msgIndex, - msgLen - msgIndex); - if (!emberAfDiscoverCommandsGeneratedResponseCallback(clusterId, - cmd->mfgCode, - discoveryComplete, - message + msgIndex, - msgLen - msgIndex)) { - emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + case ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID: { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if (msgIndex <= msgLen) + { + printDiscoverCommandsResponse(false, // is ZCL command generated? + clusterId, discoveryComplete, message + msgIndex, msgLen - msgIndex); + if (!emberAfDiscoverCommandsReceivedResponseCallback(clusterId, cmd->mfgCode, discoveryComplete, message + msgIndex, + msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + } + else + { + return false; + } + } + case ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID: { + bool discoveryComplete = emberAfGetInt8u(message, msgIndex, msgLen); + msgIndex++; + if (msgIndex <= msgLen) + { + printDiscoverCommandsResponse(true, // is ZCL command generated? + clusterId, discoveryComplete, message + msgIndex, msgLen - msgIndex); + if (!emberAfDiscoverCommandsGeneratedResponseCallback(clusterId, cmd->mfgCode, discoveryComplete, message + msgIndex, + msgLen - msgIndex)) + { + emberAfSendDefaultResponse(cmd, EMBER_ZCL_STATUS_SUCCESS); + } + return true; + } + else + { + return false; } - return true; - } else { - return false; - } } #endif default: - // MISRA requires default case. - break; - } - - kickout: - emberAfSendDefaultResponse(cmd, - (cmd->mfgSpecific - ? EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND - : EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND)); - return true; + // MISRA requires default case. + break; + } + +kickout: + emberAfSendDefaultResponse( + cmd, (cmd->mfgSpecific ? EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND : EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND)); + return true; } diff --git a/examples/wifi-echo/server/esp32/main/time-util.h b/examples/wifi-echo/server/esp32/main/time-util.h index 5f6d6bab3ea16f..26c9fa4e080308 100644 --- a/examples/wifi-echo/server/esp32/main/time-util.h +++ b/examples/wifi-echo/server/esp32/main/time-util.h @@ -31,20 +31,21 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file * @brief ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ #ifndef __TIME_UTIL_H__ #define __TIME_UTIL_H__ #define SECONDS_IN_MINUTE 60 #define SECONDS_IN_HOUR 3600 -#define SECONDS_IN_DAY (SECONDS_IN_MINUTE * 60 * 24) -#define SECONDS_IN_WEEK (SECONDS_IN_DAY * 7) -#define DURATION_FOREVER_U32 0xFFFFFFFFU +#define SECONDS_IN_DAY (SECONDS_IN_MINUTE * 60 * 24) +#define SECONDS_IN_WEEK (SECONDS_IN_DAY * 7) +#define DURATION_FOREVER_U32 0xFFFFFFFFU /** * @brief ZCL Date comparison function. @@ -54,12 +55,12 @@ * 0, if they are the same * 1, if val2 is smaller */ -int8_t emberAfCompareDates(EmberAfDate* date1, EmberAfDate* date2); +int8_t emberAfCompareDates(EmberAfDate * date1, EmberAfDate * date2); /** * @brief function that copies a ZigBee Date into a buffer */ -void emberAfCopyDate(uint8_t *data, uint16_t index, EmberAfDate *src); +void emberAfCopyDate(uint8_t * data, uint16_t index, EmberAfDate * src); /** * @brief Decode the given uint32_t into a ZCL Date object where @@ -71,32 +72,31 @@ void emberAfCopyDate(uint8_t *data, uint16_t index, EmberAfDate *src); * (0x000000FF & value) = day of week * */ -void emberAfDecodeDate(uint32_t src, EmberAfDate* dest); +void emberAfDecodeDate(uint32_t src, EmberAfDate * dest); /** * @brief Encode and return the given ZCL Date object as an uint32_t. * Refer to emberAFDecodeDate for details on how the information is stored * within an uint32_t. */ -uint32_t emberAfEncodeDate(EmberAfDate* date); +uint32_t emberAfEncodeDate(EmberAfDate * date); /** * @brief Fills the a time structure based on the passed UTC time. * */ -void emberAfFillTimeStructFromUtc(uint32_t utcTime, - EmberAfTimeStruct* returnTime); +void emberAfFillTimeStructFromUtc(uint32_t utcTime, EmberAfTimeStruct * returnTime); /** * @brief Returns the number of days in the month specified in the EmberAfTimeStruct. * */ -uint8_t emberAfGetNumberDaysInMonth(EmberAfTimeStruct *time); +uint8_t emberAfGetNumberDaysInMonth(EmberAfTimeStruct * time); /** * @brief Calculate a UTC time from the passed time structure. * */ -uint32_t emberAfGetUtcFromTimeStruct(EmberAfTimeStruct *time); +uint32_t emberAfGetUtcFromTimeStruct(EmberAfTimeStruct * time); /** * @brief Determine the week day (Monday=0 ... Sunday=6) based on diff --git a/examples/wifi-echo/server/esp32/main/types_stub.h b/examples/wifi-echo/server/esp32/main/types_stub.h index 232789681fa8b8..cd214ea3a8c881 100644 --- a/examples/wifi-echo/server/esp32/main/types_stub.h +++ b/examples/wifi-echo/server/esp32/main/types_stub.h @@ -34,8 +34,8 @@ /***************************************************************************/ /** * @file - * @brief This is a stub file for types that are external to the ZCL - * application framework. These can be redefined/modified as needed in + * @brief This is a stub file for types that are external to the ZCL + * application framework. These can be redefined/modified as needed in * the CHIP project ******************************************************************************/ @@ -54,18 +54,18 @@ typedef uint8_t EmberBindingType; enum #endif { - /** A binding that is currently not in use. */ - EMBER_UNUSED_BINDING = 0, - /** A unicast binding whose 64-bit identifier is the destination EUI64. */ - EMBER_UNICAST_BINDING = 1, - /** A unicast binding whose 64-bit identifier is the many-to-one - * destination EUI64. Route discovery should be disabled when sending - * unicasts via many-to-one bindings. */ - EMBER_MANY_TO_ONE_BINDING = 2, - /** A multicast binding whose 64-bit identifier is the group address. This - * binding can be used to send messages to the group and to receive - * messages sent to the group. */ - EMBER_MULTICAST_BINDING = 3, + /** A binding that is currently not in use. */ + EMBER_UNUSED_BINDING = 0, + /** A unicast binding whose 64-bit identifier is the destination EUI64. */ + EMBER_UNICAST_BINDING = 1, + /** A unicast binding whose 64-bit identifier is the many-to-one + * destination EUI64. Route discovery should be disabled when sending + * unicasts via many-to-one bindings. */ + EMBER_MANY_TO_ONE_BINDING = 2, + /** A multicast binding whose 64-bit identifier is the group address. This + * binding can be used to send messages to the group and to receive + * messages sent to the group. */ + EMBER_MULTICAST_BINDING = 3, }; /** @brief The type of method used for joining. * @@ -78,36 +78,36 @@ typedef uint8_t EmberJoinMethod; enum #endif { - /** Devices normally use MAC association to join a network, which respects - * the "permit joining" flag in the MAC beacon. - * This value should be used by default. - */ - EMBER_USE_MAC_ASSOCIATION = 0, - - /** For networks where the "permit joining" flag is never turned - * on, devices will need to use a ZigBee NWK Rejoin. This value causes the - * rejoin to be sent withOUT NWK security and the Trust Center will be - * asked to send the NWK key to the device. The NWK key sent to the device - * can be encrypted with the device's corresponding Trust Center link key. - * That is determined by the ::EmberJoinDecision on the Trust Center - * returned by the ::emberTrustCenterJoinHandler(). - */ - EMBER_USE_NWK_REJOIN = 1, - - /* For networks where the "permit joining" flag is never turned - * on, devices will need to use a NWK Rejoin. If those devices have been - * preconfigured with the NWK key (including sequence number), they can use - * a secured rejoin. This is only necessary for end devices since they need - * a parent. Routers can simply use the ::EMBER_USE_CONFIGURED_NWK_STATE - * join method below. - */ - EMBER_USE_NWK_REJOIN_HAVE_NWK_KEY = 2, - - /** For networks where all network and security information is known - ahead of time, a router device may be commissioned such that it does - not need to send any messages to begin communicating on the network. - */ - EMBER_USE_CONFIGURED_NWK_STATE = 3, + /** Devices normally use MAC association to join a network, which respects + * the "permit joining" flag in the MAC beacon. + * This value should be used by default. + */ + EMBER_USE_MAC_ASSOCIATION = 0, + + /** For networks where the "permit joining" flag is never turned + * on, devices will need to use a ZigBee NWK Rejoin. This value causes the + * rejoin to be sent withOUT NWK security and the Trust Center will be + * asked to send the NWK key to the device. The NWK key sent to the device + * can be encrypted with the device's corresponding Trust Center link key. + * That is determined by the ::EmberJoinDecision on the Trust Center + * returned by the ::emberTrustCenterJoinHandler(). + */ + EMBER_USE_NWK_REJOIN = 1, + + /* For networks where the "permit joining" flag is never turned + * on, devices will need to use a NWK Rejoin. If those devices have been + * preconfigured with the NWK key (including sequence number), they can use + * a secured rejoin. This is only necessary for end devices since they need + * a parent. Routers can simply use the ::EMBER_USE_CONFIGURED_NWK_STATE + * join method below. + */ + EMBER_USE_NWK_REJOIN_HAVE_NWK_KEY = 2, + + /** For networks where all network and security information is known + ahead of time, a router device may be commissioned such that it does + not need to send any messages to begin communicating on the network. + */ + EMBER_USE_CONFIGURED_NWK_STATE = 3, }; /** @@ -120,23 +120,23 @@ typedef uint8_t EmberVersionType; enum #endif { - EMBER_VERSION_TYPE_PRE_RELEASE = 0x00, - - //Alpha, should be used rarely - EMBER_VERSION_TYPE_ALPHA_1 = 0x11, - EMBER_VERSION_TYPE_ALPHA_2 = 0x12, - EMBER_VERSION_TYPE_ALPHA_3 = 0x13, - // Leave space in case we decide to add other types in the future. - EMBER_VERSION_TYPE_BETA_1 = 0x21, - EMBER_VERSION_TYPE_BETA_2 = 0x22, - EMBER_VERSION_TYPE_BETA_3 = 0x23, - - // Anything other than 0xAA is considered pre-release - // Silicon Labs may define other types in the future (e.g. beta, alpha) - // Silicon Labs chose an arbitrary number (0xAA) to allow for expansion, but - // to prevent ambiguity in case 0x00 or 0xFF is accidentally retrieved - // as the version type. - EMBER_VERSION_TYPE_GA = 0xAA, + EMBER_VERSION_TYPE_PRE_RELEASE = 0x00, + + // Alpha, should be used rarely + EMBER_VERSION_TYPE_ALPHA_1 = 0x11, + EMBER_VERSION_TYPE_ALPHA_2 = 0x12, + EMBER_VERSION_TYPE_ALPHA_3 = 0x13, + // Leave space in case we decide to add other types in the future. + EMBER_VERSION_TYPE_BETA_1 = 0x21, + EMBER_VERSION_TYPE_BETA_2 = 0x22, + EMBER_VERSION_TYPE_BETA_3 = 0x23, + + // Anything other than 0xAA is considered pre-release + // Silicon Labs may define other types in the future (e.g. beta, alpha) + // Silicon Labs chose an arbitrary number (0xAA) to allow for expansion, but + // to prevent ambiguity in case 0x00 or 0xFF is accidentally retrieved + // as the version type. + EMBER_VERSION_TYPE_GA = 0xAA, }; /** @@ -150,16 +150,16 @@ typedef uint8_t EmberEventUnits; enum #endif { - /** The event is not scheduled to run. */ - EMBER_EVENT_INACTIVE = 0, - /** The execution time is in approximate milliseconds. */ - EMBER_EVENT_MS_TIME, - /** The execution time is in 'binary' quarter seconds (256 timer ticks). */ - EMBER_EVENT_QS_TIME, - /** The execution time is in 'binary' minutes (65536 timer ticks). */ - EMBER_EVENT_MINUTE_TIME, - /** The event is scheduled to run at the earliest opportunity. */ - EMBER_EVENT_ZERO_DELAY + /** The event is not scheduled to run. */ + EMBER_EVENT_INACTIVE = 0, + /** The execution time is in approximate milliseconds. */ + EMBER_EVENT_MS_TIME, + /** The execution time is in 'binary' quarter seconds (256 timer ticks). */ + EMBER_EVENT_QS_TIME, + /** The execution time is in 'binary' minutes (65536 timer ticks). */ + EMBER_EVENT_MINUTE_TIME, + /** The event is scheduled to run at the earliest opportunity. */ + EMBER_EVENT_ZERO_DELAY }; /** @brief An identifier for a task */ typedef uint8_t EmberTaskId; @@ -177,87 +177,87 @@ typedef uint16_t EmberApsOption; enum #endif { - /** No options. */ - EMBER_APS_OPTION_NONE = 0x0000, + /** No options. */ + EMBER_APS_OPTION_NONE = 0x0000, #ifndef DOXYGEN_SHOULD_SKIP_THIS - EMBER_APS_OPTION_ENCRYPT_WITH_TRANSIENT_KEY = 0x0001, - EMBER_APS_OPTION_USE_ALIAS_SEQUENCE_NUMBER = 0x0002, + EMBER_APS_OPTION_ENCRYPT_WITH_TRANSIENT_KEY = 0x0001, + EMBER_APS_OPTION_USE_ALIAS_SEQUENCE_NUMBER = 0x0002, #endif - /** This signs the application layer message body (APS Frame not included) - and appends the ECDSA signature to the end of the message, which is needed by - Smart Energy applications and requires the CBKE and ECC libraries. - The ::emberDsaSignHandler() function is called after DSA signing - is complete but before the message has been sent by the APS layer. - Note that when passing a buffer to the stack for DSA signing, the final - byte in the buffer has a special significance as an indicator of how many - leading bytes should be ignored for signature purposes. See the API - documentation of emberDsaSign() or the dsaSign EZSP command for more - details about this requirement. - */ - EMBER_APS_OPTION_DSA_SIGN = 0x0010, - /** Send the message using APS Encryption using the Link Key shared - with the destination node to encrypt the data at the APS Level. */ - EMBER_APS_OPTION_ENCRYPTION = 0x0020, - /** Resend the message using the APS retry mechanism. - This option and the enable route discovery option must be enabled for - an existing route to be repaired automatically. */ - EMBER_APS_OPTION_RETRY = 0x0040, - /** Send the message with the NWK 'enable route discovery' flag, which - causes a route discovery to be initiated if no route to the destination - is known. Note that in the mesh stack, this option and the APS retry - option must be enabled an existing route to be repaired - automatically. */ - EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY = 0x0100, - /** Send the message with the NWK 'force route discovery' flag, which causes - a route discovery to be initiated even if one is known. */ - EMBER_APS_OPTION_FORCE_ROUTE_DISCOVERY = 0x0200, - /** Include the source EUI64 in the network frame. */ - EMBER_APS_OPTION_SOURCE_EUI64 = 0x0400, - /** Include the destination EUI64 in the network frame. */ - EMBER_APS_OPTION_DESTINATION_EUI64 = 0x0800, - /** Send a ZDO request to discover the node ID of the destination if it is - not already known. */ - EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY = 0x1000, - /** This message is being sent in response to a call to - ::emberPollHandler(). It causes the message to be sent - immediately instead of being queued up until the next poll from the - (end device) destination. */ - EMBER_APS_OPTION_POLL_RESPONSE = 0x2000, - /** This incoming message is a valid ZDO request and the application - * is responsible for sending a ZDO response. This flag is used only - * within emberIncomingMessageHandler() when - * EMBER_APPLICATION_RECEIVES_UNSUPPORTED_ZDO_REQUESTS is defined. */ - EMBER_APS_OPTION_ZDO_RESPONSE_REQUIRED = 0x4000, - /** This message is part of a fragmented message. This option may only - be set for unicasts. The groupId field gives the index of this - fragment in the low-order byte. If the low-order byte is zero this - is the first fragment and the high-order byte contains the number - of fragments in the message. */ - EMBER_APS_OPTION_FRAGMENT = 0x8000 + /** This signs the application layer message body (APS Frame not included) + and appends the ECDSA signature to the end of the message, which is needed by + Smart Energy applications and requires the CBKE and ECC libraries. + The ::emberDsaSignHandler() function is called after DSA signing + is complete but before the message has been sent by the APS layer. + Note that when passing a buffer to the stack for DSA signing, the final + byte in the buffer has a special significance as an indicator of how many + leading bytes should be ignored for signature purposes. See the API + documentation of emberDsaSign() or the dsaSign EZSP command for more + details about this requirement. + */ + EMBER_APS_OPTION_DSA_SIGN = 0x0010, + /** Send the message using APS Encryption using the Link Key shared + with the destination node to encrypt the data at the APS Level. */ + EMBER_APS_OPTION_ENCRYPTION = 0x0020, + /** Resend the message using the APS retry mechanism. + This option and the enable route discovery option must be enabled for + an existing route to be repaired automatically. */ + EMBER_APS_OPTION_RETRY = 0x0040, + /** Send the message with the NWK 'enable route discovery' flag, which + causes a route discovery to be initiated if no route to the destination + is known. Note that in the mesh stack, this option and the APS retry + option must be enabled an existing route to be repaired + automatically. */ + EMBER_APS_OPTION_ENABLE_ROUTE_DISCOVERY = 0x0100, + /** Send the message with the NWK 'force route discovery' flag, which causes + a route discovery to be initiated even if one is known. */ + EMBER_APS_OPTION_FORCE_ROUTE_DISCOVERY = 0x0200, + /** Include the source EUI64 in the network frame. */ + EMBER_APS_OPTION_SOURCE_EUI64 = 0x0400, + /** Include the destination EUI64 in the network frame. */ + EMBER_APS_OPTION_DESTINATION_EUI64 = 0x0800, + /** Send a ZDO request to discover the node ID of the destination if it is + not already known. */ + EMBER_APS_OPTION_ENABLE_ADDRESS_DISCOVERY = 0x1000, + /** This message is being sent in response to a call to + ::emberPollHandler(). It causes the message to be sent + immediately instead of being queued up until the next poll from the + (end device) destination. */ + EMBER_APS_OPTION_POLL_RESPONSE = 0x2000, + /** This incoming message is a valid ZDO request and the application + * is responsible for sending a ZDO response. This flag is used only + * within emberIncomingMessageHandler() when + * EMBER_APPLICATION_RECEIVES_UNSUPPORTED_ZDO_REQUESTS is defined. */ + EMBER_APS_OPTION_ZDO_RESPONSE_REQUIRED = 0x4000, + /** This message is part of a fragmented message. This option may only + be set for unicasts. The groupId field gives the index of this + fragment in the low-order byte. If the low-order byte is zero this + is the first fragment and the high-order byte contains the number + of fragments in the message. */ + EMBER_APS_OPTION_FRAGMENT = 0x8000 }; - /** @brief An in-memory representation of a ZigBee APS frame * of an incoming or outgoing message. */ -typedef struct { - /** The application profile ID that describes the format of the message. */ - uint16_t profileId; - /** The cluster ID for this message. */ - uint16_t clusterId; - /** The source endpoint. */ - uint8_t sourceEndpoint; - /** The destination endpoint. */ - uint8_t destinationEndpoint; - /** A bitmask of options from the enumeration above. */ - EmberApsOption options; - /** The group ID for this message, if it is multicast mode. */ - uint16_t groupId; - /** The sequence number. */ - uint8_t sequence; - uint8_t radius; +typedef struct +{ + /** The application profile ID that describes the format of the message. */ + uint16_t profileId; + /** The cluster ID for this message. */ + uint16_t clusterId; + /** The source endpoint. */ + uint8_t sourceEndpoint; + /** The destination endpoint. */ + uint8_t destinationEndpoint; + /** A bitmask of options from the enumeration above. */ + EmberApsOption options; + /** The group ID for this message, if it is multicast mode. */ + uint16_t groupId; + /** The sequence number. */ + uint8_t sequence; + uint8_t radius; } EmberApsFrame; /** @@ -303,14 +303,14 @@ typedef uint8_t EmberTcLinkKeyRequestPolicy; enum #endif { - EMBER_DENY_TC_LINK_KEY_REQUESTS = 0x00, - EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY = 0x01, - // When using the following mode a unique random link key is created. - // The key which is generated due to this mode is added to the link - // key table. Therefore make sure that the link key table size is not - // zero as this can result in the newly generated key not being saved - // and communication breaking between the trust center and the nodes. - EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_GENERATE_NEW_KEY = 0x02 + EMBER_DENY_TC_LINK_KEY_REQUESTS = 0x00, + EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY = 0x01, + // When using the following mode a unique random link key is created. + // The key which is generated due to this mode is added to the link + // key table. Therefore make sure that the link key table size is not + // zero as this can result in the newly generated key not being saved + // and communication breaking between the trust center and the nodes. + EMBER_ALLOW_TC_LINK_KEY_REQUEST_AND_GENERATE_NEW_KEY = 0x02 }; /** @brief This enumeration determines whether or not a Trust Center @@ -323,11 +323,10 @@ typedef uint8_t EmberAppLinkKeyRequestPolicy; enum #endif { - EMBER_DENY_APP_LINK_KEY_REQUESTS = 0x00, - EMBER_ALLOW_APP_LINK_KEY_REQUEST = 0x01 + EMBER_DENY_APP_LINK_KEY_REQUESTS = 0x00, + EMBER_ALLOW_APP_LINK_KEY_REQUEST = 0x01 }; - /** @brief This is the Extended Security Bitmask that controls the use * of various extended security features. */ @@ -339,57 +338,58 @@ enum #endif { #ifndef DOXYGEN_SHOULD_SKIP_THIS - // If this bit is set, the 'key token data' field is set in the Initial - // Security Bitmask to 0 (No Preconfig Key token). Otherwise, the - // field is left as is. - EMBER_PRECONFIG_KEY_NOT_VALID = 0x0001, + // If this bit is set, the 'key token data' field is set in the Initial + // Security Bitmask to 0 (No Preconfig Key token). Otherwise, the + // field is left as is. + EMBER_PRECONFIG_KEY_NOT_VALID = 0x0001, #endif - // bits 2-3 are unused. - /** This denotes that the network key update can only happen if the network - key update request is unicast and encrypted i.e. broadcast network key update - requests will not be processed if bit 1 is set*/ - EMBER_SECURE_NETWORK_KEY_ROTATION = 0x0002, + // bits 2-3 are unused. + /** This denotes that the network key update can only happen if the network + key update request is unicast and encrypted i.e. broadcast network key update + requests will not be processed if bit 1 is set*/ + EMBER_SECURE_NETWORK_KEY_ROTATION = 0x0002, - /** This denotes whether a joiner node (router or end-device) uses a Global - Link Key or a Unique Link Key. */ - EMBER_JOINER_GLOBAL_LINK_KEY = 0x0010, + /** This denotes whether a joiner node (router or end-device) uses a Global + Link Key or a Unique Link Key. */ + EMBER_JOINER_GLOBAL_LINK_KEY = 0x0010, - /** This denotes whether the device's outgoing frame counter is allowed to - be reset during forming or joining. If the flag is set, the outgoing frame - counter is not allowed to be reset. If the flag is not set, the frame - counter is allowed to be reset. */ + /** This denotes whether the device's outgoing frame counter is allowed to + be reset during forming or joining. If the flag is set, the outgoing frame + counter is not allowed to be reset. If the flag is not set, the frame + counter is allowed to be reset. */ - EMBER_EXT_NO_FRAME_COUNTER_RESET = 0x0020, + EMBER_EXT_NO_FRAME_COUNTER_RESET = 0x0020, - /** This denotes whether a device should discard or accept network leave - without rejoin commands. */ - EMBER_NWK_LEAVE_WITHOUT_REJOIN_NOT_ALLOWED = 0x0040, + /** This denotes whether a device should discard or accept network leave + without rejoin commands. */ + EMBER_NWK_LEAVE_WITHOUT_REJOIN_NOT_ALLOWED = 0x0040, - // Bit 7 reserved for future use (stored in TOKEN). + // Bit 7 reserved for future use (stored in TOKEN). - /** This denotes whether a router node should discard or accept network Leave - Commands. */ - EMBER_NWK_LEAVE_REQUEST_NOT_ALLOWED = 0x0100, + /** This denotes whether a router node should discard or accept network Leave + Commands. */ + EMBER_NWK_LEAVE_REQUEST_NOT_ALLOWED = 0x0100, #ifndef DOXYGEN_SHOULD_SKIP_THIS - /** This denotes whether a node is running the latest stack specification or - is emulating R18 specs behavior. If this flag is enabled, a router - node should only send encrypted Update Device messages while the TC should - only accept encrypted Updated Device messages.*/ - EMBER_R18_STACK_BEHAVIOR = 0x0200, + /** This denotes whether a node is running the latest stack specification or + is emulating R18 specs behavior. If this flag is enabled, a router + node should only send encrypted Update Device messages while the TC should + only accept encrypted Updated Device messages.*/ + EMBER_R18_STACK_BEHAVIOR = 0x0200, #endif - // Bit 10 is reserved for future use (stored in TOKEN). - // Bit 11 is reserved for future use(stored in RAM). - // Bits 12-15 are unused. + // Bit 10 is reserved for future use (stored in TOKEN). + // Bit 11 is reserved for future use(stored in RAM). + // Bits 12-15 are unused. }; /** @brief This data structure contains the key data that is passed * into various other functions. */ -typedef struct { - /** This is the key byte data. */ - uint8_t contents[EMBER_ENCRYPTION_KEY_SIZE]; +typedef struct +{ + /** This is the key byte data. */ + uint8_t contents[EMBER_ENCRYPTION_KEY_SIZE]; } EmberKeyData; /** * @brief Defines the possible types of nodes and the roles that a @@ -403,18 +403,18 @@ typedef uint8_t EmberNodeType; enum #endif { - /** The device is not joined. */ - EMBER_UNKNOWN_DEVICE = 0, - /** Will relay messages and can act as a parent to other nodes. */ - EMBER_COORDINATOR = 1, - /** Will relay messages and can act as a parent to other nodes. */ - EMBER_ROUTER = 2, - /** Communicates only with its parent and will not relay messages. */ - EMBER_END_DEVICE = 3, - /** An end device whose radio can be turned off to save power. - * The application must call ::emberPollForData() to receive messages. - */ - EMBER_SLEEPY_END_DEVICE = 4, + /** The device is not joined. */ + EMBER_UNKNOWN_DEVICE = 0, + /** Will relay messages and can act as a parent to other nodes. */ + EMBER_COORDINATOR = 1, + /** Will relay messages and can act as a parent to other nodes. */ + EMBER_ROUTER = 2, + /** Communicates only with its parent and will not relay messages. */ + EMBER_END_DEVICE = 3, + /** An end device whose radio can be turned off to save power. + * The application must call ::emberPollForData() to receive messages. + */ + EMBER_SLEEPY_END_DEVICE = 4, }; /** @@ -427,18 +427,18 @@ typedef uint8_t EmberIncomingMessageType; enum #endif { - /** Unicast. */ - EMBER_INCOMING_UNICAST, - /** Unicast reply. */ - EMBER_INCOMING_UNICAST_REPLY, - /** Multicast. */ - EMBER_INCOMING_MULTICAST, - /** Multicast sent by the local device. */ - EMBER_INCOMING_MULTICAST_LOOPBACK, - /** Broadcast. */ - EMBER_INCOMING_BROADCAST, - /** Broadcast sent by the local device. */ - EMBER_INCOMING_BROADCAST_LOOPBACK + /** Unicast. */ + EMBER_INCOMING_UNICAST, + /** Unicast reply. */ + EMBER_INCOMING_UNICAST_REPLY, + /** Multicast. */ + EMBER_INCOMING_MULTICAST, + /** Multicast sent by the local device. */ + EMBER_INCOMING_MULTICAST_LOOPBACK, + /** Broadcast. */ + EMBER_INCOMING_BROADCAST, + /** Broadcast sent by the local device. */ + EMBER_INCOMING_BROADCAST_LOOPBACK }; /** @@ -451,24 +451,24 @@ typedef uint8_t EmberOutgoingMessageType; enum #endif { - /** Unicast sent directly to an EmberNodeId. */ - EMBER_OUTGOING_DIRECT, - /** Unicast sent using an entry in the address table. */ - EMBER_OUTGOING_VIA_ADDRESS_TABLE, - /** Unicast sent using an entry in the binding table. */ - EMBER_OUTGOING_VIA_BINDING, - /** Multicast message. This value is passed to emberMessageSentHandler() only. - * It may not be passed to emberSendUnicast(). */ - EMBER_OUTGOING_MULTICAST, - /** An aliased multicast message. This value is passed to emberMessageSentHandler() only. - * It may not be passed to emberSendUnicast(). */ - EMBER_OUTGOING_MULTICAST_WITH_ALIAS, - /** An aliased Broadcast message. This value is passed to emberMessageSentHandler() only. - * It may not be passed to emberSendUnicast(). */ - EMBER_OUTGOING_BROADCAST_WITH_ALIAS, - /** A broadcast message. This value is passed to emberMessageSentHandler() only. - * It may not be passed to emberSendUnicast(). */ - EMBER_OUTGOING_BROADCAST + /** Unicast sent directly to an EmberNodeId. */ + EMBER_OUTGOING_DIRECT, + /** Unicast sent using an entry in the address table. */ + EMBER_OUTGOING_VIA_ADDRESS_TABLE, + /** Unicast sent using an entry in the binding table. */ + EMBER_OUTGOING_VIA_BINDING, + /** Multicast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_MULTICAST, + /** An aliased multicast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_MULTICAST_WITH_ALIAS, + /** An aliased Broadcast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_BROADCAST_WITH_ALIAS, + /** A broadcast message. This value is passed to emberMessageSentHandler() only. + * It may not be passed to emberSendUnicast(). */ + EMBER_OUTGOING_BROADCAST }; /** @brief Endpoint information (a ZigBee Simple Descriptor). @@ -478,17 +478,18 @@ enum * network by the ZDO. */ -typedef struct { - /** Identifies the endpoint's application profile. */ - uint16_t profileId; - /** The endpoint's device ID within the application profile. */ - uint16_t deviceId; - /** The endpoint's device version. */ - uint8_t deviceVersion; - /** The number of input clusters. */ - uint8_t inputClusterCount; - /** The number of output clusters. */ - uint8_t outputClusterCount; +typedef struct +{ + /** Identifies the endpoint's application profile. */ + uint16_t profileId; + /** The endpoint's device ID within the application profile. */ + uint16_t deviceId; + /** The endpoint's device version. */ + uint8_t deviceVersion; + /** The number of input clusters. */ + uint8_t inputClusterCount; + /** The number of output clusters. */ + uint8_t outputClusterCount; } EmberEndpointDescription; /** @brief A type of packet received by the stack @@ -504,37 +505,38 @@ typedef uint8_t EmberZigbeePacketType; enum #endif { - /** Describes an 802.15.4 raw MAC message, unprocessed by the stack. */ - EMBER_ZIGBEE_PACKET_TYPE_RAW_MAC, - /** Describes an 802.15.4 MAC layer command. */ - EMBER_ZIGBEE_PACKET_TYPE_MAC_COMMAND, - /** Describes a ZigBee Network layer data message. */ - EMBER_ZIGBEE_PACKET_TYPE_NWK_DATA, - /** Describes a ZigBee Network layer command. */ - EMBER_ZIGBEE_PACKET_TYPE_NWK_COMMAND, - /** Describes a ZigBee Application Support layer data message. */ - EMBER_ZIGBEE_PACKET_TYPE_APS_DATA, - /** Describes a ZigBee Application Support layer command. */ - EMBER_ZIGBEE_PACKET_TYPE_APS_COMMAND, - /** Describes a ZigBee Device Object command. */ - EMBER_ZIGBEE_PACKET_TYPE_ZDO, - /** Describes a ZigBee Cluster Library command. */ - EMBER_ZIGBEE_PACKET_TYPE_ZCL, - - /** Distinguishing between raw MAC and beacons for simplicity */ - EMBER_ZIGBEE_PACKET_TYPE_BEACON, + /** Describes an 802.15.4 raw MAC message, unprocessed by the stack. */ + EMBER_ZIGBEE_PACKET_TYPE_RAW_MAC, + /** Describes an 802.15.4 MAC layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_MAC_COMMAND, + /** Describes a ZigBee Network layer data message. */ + EMBER_ZIGBEE_PACKET_TYPE_NWK_DATA, + /** Describes a ZigBee Network layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_NWK_COMMAND, + /** Describes a ZigBee Application Support layer data message. */ + EMBER_ZIGBEE_PACKET_TYPE_APS_DATA, + /** Describes a ZigBee Application Support layer command. */ + EMBER_ZIGBEE_PACKET_TYPE_APS_COMMAND, + /** Describes a ZigBee Device Object command. */ + EMBER_ZIGBEE_PACKET_TYPE_ZDO, + /** Describes a ZigBee Cluster Library command. */ + EMBER_ZIGBEE_PACKET_TYPE_ZCL, + + /** Distinguishing between raw MAC and beacons for simplicity */ + EMBER_ZIGBEE_PACKET_TYPE_BEACON, }; /** * @brief Defines a ZigBee network and the associated parameters. */ -typedef struct { - uint16_t panId; - uint8_t channel; - bool allowingJoin; - uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; - uint8_t stackProfile; - uint8_t nwkUpdateId; +typedef struct +{ + uint16_t panId; + uint8_t channel; + bool allowingJoin; + uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; + uint8_t stackProfile; + uint8_t nwkUpdateId; } EmberZigbeeNetwork; /** @brief indication of the action taken on a packet */ @@ -545,9 +547,9 @@ typedef uint8_t EmberPacketAction; enum #endif { - EMBER_DROP_PACKET = 0, - EMBER_ACCEPT_PACKET = 1, - EMBER_MANGLE_PACKET, + EMBER_DROP_PACKET = 0, + EMBER_ACCEPT_PACKET = 1, + EMBER_MANGLE_PACKET, }; /** @@ -567,102 +569,102 @@ typedef uint8_t EmberZdoStatus; enum #endif { - // These values are taken from Table 48 of ZDP Errata 043238r003 and Table 2 - // of NWK 02130r10. - EMBER_ZDP_SUCCESS = 0x00, - // 0x01 to 0x7F are reserved - EMBER_ZDP_INVALID_REQUEST_TYPE = 0x80, - EMBER_ZDP_DEVICE_NOT_FOUND = 0x81, - EMBER_ZDP_INVALID_ENDPOINT = 0x82, - EMBER_ZDP_NOT_ACTIVE = 0x83, - EMBER_ZDP_NOT_SUPPORTED = 0x84, - EMBER_ZDP_TIMEOUT = 0x85, - EMBER_ZDP_NO_MATCH = 0x86, - // 0x87 is reserved = 0x87, - EMBER_ZDP_NO_ENTRY = 0x88, - EMBER_ZDP_NO_DESCRIPTOR = 0x89, - EMBER_ZDP_INSUFFICIENT_SPACE = 0x8a, - EMBER_ZDP_NOT_PERMITTED = 0x8b, - EMBER_ZDP_TABLE_FULL = 0x8c, - EMBER_ZDP_NOT_AUTHORIZED = 0x8d, - EMBER_ZDP_DEVICE_BINDING_TABLE_FULL = 0x8e, - EMBER_ZDP_INVALID_INDEX = 0x8f, - - EMBER_NWK_ALREADY_PRESENT = 0xC5, - EMBER_NWK_TABLE_FULL = 0xC7, - EMBER_NWK_UNKNOWN_DEVICE = 0xC8 + // These values are taken from Table 48 of ZDP Errata 043238r003 and Table 2 + // of NWK 02130r10. + EMBER_ZDP_SUCCESS = 0x00, + // 0x01 to 0x7F are reserved + EMBER_ZDP_INVALID_REQUEST_TYPE = 0x80, + EMBER_ZDP_DEVICE_NOT_FOUND = 0x81, + EMBER_ZDP_INVALID_ENDPOINT = 0x82, + EMBER_ZDP_NOT_ACTIVE = 0x83, + EMBER_ZDP_NOT_SUPPORTED = 0x84, + EMBER_ZDP_TIMEOUT = 0x85, + EMBER_ZDP_NO_MATCH = 0x86, + // 0x87 is reserved = 0x87, + EMBER_ZDP_NO_ENTRY = 0x88, + EMBER_ZDP_NO_DESCRIPTOR = 0x89, + EMBER_ZDP_INSUFFICIENT_SPACE = 0x8a, + EMBER_ZDP_NOT_PERMITTED = 0x8b, + EMBER_ZDP_TABLE_FULL = 0x8c, + EMBER_ZDP_NOT_AUTHORIZED = 0x8d, + EMBER_ZDP_DEVICE_BINDING_TABLE_FULL = 0x8e, + EMBER_ZDP_INVALID_INDEX = 0x8f, + + EMBER_NWK_ALREADY_PRESENT = 0xC5, + EMBER_NWK_TABLE_FULL = 0xC7, + EMBER_NWK_UNKNOWN_DEVICE = 0xC8 }; - /** @brief Defines an entry in the binding table. * * A binding entry specifies a local endpoint, a remote endpoint, a * cluster ID and either the destination EUI64 (for unicast bindings) or the * 64-bit group address (for multicast bindings). */ -typedef struct { - /** The type of binding. */ - EmberBindingType type; - /** The endpoint on the local node. */ - uint8_t local; - /** A cluster ID that matches one from the local endpoint's simple descriptor. - * This cluster ID is set by the provisioning application to indicate which - * part an endpoint's functionality is bound to this particular remote node - * and is used to distinguish between unicast and multicast bindings. Note - * that a binding can be used to to send messages with any cluster ID, not - * just that listed in the binding. - */ - uint16_t clusterId; - /** The endpoint on the remote node (specified by \c identifier). */ - uint8_t remote; - /** A 64-bit identifier. This is either: - * - The destination EUI64, for unicasts. - * - A 16-bit multicast group address, for multicasts. - */ - EmberEUI64 identifier; - /** The index of the network the binding belongs to. */ - uint8_t networkIndex; +typedef struct +{ + /** The type of binding. */ + EmberBindingType type; + /** The endpoint on the local node. */ + uint8_t local; + /** A cluster ID that matches one from the local endpoint's simple descriptor. + * This cluster ID is set by the provisioning application to indicate which + * part an endpoint's functionality is bound to this particular remote node + * and is used to distinguish between unicast and multicast bindings. Note + * that a binding can be used to to send messages with any cluster ID, not + * just that listed in the binding. + */ + uint16_t clusterId; + /** The endpoint on the remote node (specified by \c identifier). */ + uint8_t remote; + /** A 64-bit identifier. This is either: + * - The destination EUI64, for unicasts. + * - A 16-bit multicast group address, for multicasts. + */ + EmberEUI64 identifier; + /** The index of the network the binding belongs to. */ + uint8_t networkIndex; } EmberBindingTableEntry; - /** @brief This describes the Initial Security features and requirements that * will be used when forming or joining the network. */ -typedef struct { - /** This bitmask enumerates which security features should be used - and the presence of valid data within other elements of the - ::EmberInitialSecurityState data structure. For more details, see the - ::EmberInitialSecurityBitmask. */ - uint16_t bitmask; - /** This is the pre-configured key that can be used by devices when joining the - * network if the Trust Center does not send the initial security data - * in-the-clear. - * For the Trust Center, it will be the global link key and must be set - * regardless of whether joining devices are expected to have a pre-configured - * Link Key. - * This parameter will only be used if the EmberInitialSecurityState::bitmask - * sets the bit indicating ::EMBER_HAVE_PRECONFIGURED_KEY. */ - EmberKeyData preconfiguredKey; - /** This is the Network Key used when initially forming the network. - * It must be set on the Trust Center and is not needed for devices - * joining the network. This parameter will only be used if the - * EmberInitialSecurityState::bitmask sets the bit indicating - * ::EMBER_HAVE_NETWORK_KEY. */ - EmberKeyData networkKey; - /** This is the sequence number associated with the network key. It must - * be set if the Network Key is set and is used to indicate a particular - * of the network key for updating and switching. This parameter will - * only be used if the ::EMBER_HAVE_NETWORK_KEY is set. Generally, it should - * be set to 0 when forming the network; joining devices can ignore - * this value. */ - uint8_t networkKeySequenceNumber; - /** This is the long address of the trust center on the network that will - * be joined. It is usually NOT set prior to joining the network and - * is learned during the joining message exchange. This field - * is only examined if ::EMBER_HAVE_TRUST_CENTER_EUI64 is set in the - * EmberInitialSecurityState::bitmask. Most devices should clear that - * bit and leave this field alone. This field must be set when using - * commissioning mode. It is required to be in little-endian format. */ - EmberEUI64 preconfiguredTrustCenterEui64; +typedef struct +{ + /** This bitmask enumerates which security features should be used + and the presence of valid data within other elements of the + ::EmberInitialSecurityState data structure. For more details, see the + ::EmberInitialSecurityBitmask. */ + uint16_t bitmask; + /** This is the pre-configured key that can be used by devices when joining the + * network if the Trust Center does not send the initial security data + * in-the-clear. + * For the Trust Center, it will be the global link key and must be set + * regardless of whether joining devices are expected to have a pre-configured + * Link Key. + * This parameter will only be used if the EmberInitialSecurityState::bitmask + * sets the bit indicating ::EMBER_HAVE_PRECONFIGURED_KEY. */ + EmberKeyData preconfiguredKey; + /** This is the Network Key used when initially forming the network. + * It must be set on the Trust Center and is not needed for devices + * joining the network. This parameter will only be used if the + * EmberInitialSecurityState::bitmask sets the bit indicating + * ::EMBER_HAVE_NETWORK_KEY. */ + EmberKeyData networkKey; + /** This is the sequence number associated with the network key. It must + * be set if the Network Key is set and is used to indicate a particular + * of the network key for updating and switching. This parameter will + * only be used if the ::EMBER_HAVE_NETWORK_KEY is set. Generally, it should + * be set to 0 when forming the network; joining devices can ignore + * this value. */ + uint8_t networkKeySequenceNumber; + /** This is the long address of the trust center on the network that will + * be joined. It is usually NOT set prior to joining the network and + * is learned during the joining message exchange. This field + * is only examined if ::EMBER_HAVE_TRUST_CENTER_EUI64 is set in the + * EmberInitialSecurityState::bitmask. Most devices should clear that + * bit and leave this field alone. This field must be set when using + * commissioning mode. It is required to be in little-endian format. */ + EmberEUI64 preconfiguredTrustCenterEui64; } EmberInitialSecurityState; /** @brief The Status of the Update Device message sent to the Trust Center. @@ -679,10 +681,10 @@ typedef uint8_t EmberDeviceUpdate; enum #endif { - EMBER_STANDARD_SECURITY_SECURED_REJOIN = 0, - EMBER_STANDARD_SECURITY_UNSECURED_JOIN = 1, - EMBER_DEVICE_LEFT = 2, - EMBER_STANDARD_SECURITY_UNSECURED_REJOIN = 3, + EMBER_STANDARD_SECURITY_SECURED_REJOIN = 0, + EMBER_STANDARD_SECURITY_UNSECURED_JOIN = 1, + EMBER_DEVICE_LEFT = 2, + EMBER_STANDARD_SECURITY_UNSECURED_REJOIN = 3, }; /** @@ -695,14 +697,14 @@ typedef uint8_t EmberJoinDecision; enum #endif { - /** Allow the node to join. The node has the key. */ - EMBER_USE_PRECONFIGURED_KEY = 0, - /** Allow the node to join. Send the key to the node. */ - EMBER_SEND_KEY_IN_THE_CLEAR, - /** Deny join. */ - EMBER_DENY_JOIN, - /** Take no action. */ - EMBER_NO_ACTION + /** Allow the node to join. The node has the key. */ + EMBER_USE_PRECONFIGURED_KEY = 0, + /** Allow the node to join. Send the key to the node. */ + EMBER_SEND_KEY_IN_THE_CLEAR, + /** Deny join. */ + EMBER_DENY_JOIN, + /** Take no action. */ + EMBER_NO_ACTION }; /** @brief This denotes the status of an attempt to establish @@ -715,46 +717,46 @@ typedef uint8_t EmberKeyStatus; enum #endif { - EMBER_KEY_STATUS_NONE = 0x00, - EMBER_APP_LINK_KEY_ESTABLISHED = 0x01, - EMBER_TRUST_CENTER_LINK_KEY_ESTABLISHED = 0x03, - - EMBER_KEY_ESTABLISHMENT_TIMEOUT = 0x04, - EMBER_KEY_TABLE_FULL = 0x05, - - // These are success status values applying only to the - // Trust Center answering key requests. - EMBER_TC_RESPONDED_TO_KEY_REQUEST = 0x06, - EMBER_TC_APP_KEY_SENT_TO_REQUESTER = 0x07, - - // These are failure status values applying only to the - // Trust Center answering key requests. - EMBER_TC_RESPONSE_TO_KEY_REQUEST_FAILED = 0x08, - EMBER_TC_REQUEST_KEY_TYPE_NOT_SUPPORTED = 0x09, - EMBER_TC_NO_LINK_KEY_FOR_REQUESTER = 0x0A, - EMBER_TC_REQUESTER_EUI64_UNKNOWN = 0x0B, - EMBER_TC_RECEIVED_FIRST_APP_KEY_REQUEST = 0x0C, - EMBER_TC_TIMEOUT_WAITING_FOR_SECOND_APP_KEY_REQUEST = 0x0D, - EMBER_TC_NON_MATCHING_APP_KEY_REQUEST_RECEIVED = 0x0E, - EMBER_TC_FAILED_TO_SEND_APP_KEYS = 0x0F, - EMBER_TC_FAILED_TO_STORE_APP_KEY_REQUEST = 0x10, - EMBER_TC_REJECTED_APP_KEY_REQUEST = 0x11, - EMBER_TC_FAILED_TO_GENERATE_NEW_KEY = 0x12, - EMBER_TC_FAILED_TO_SEND_TC_KEY = 0x13, - - // These are generic status values for a key requester. - EMBER_TRUST_CENTER_IS_PRE_R21 = 0x1E, - - // These are status values applying only to the Trust Center - // verifying link keys. - EMBER_TC_REQUESTER_VERIFY_KEY_TIMEOUT = 0x32, - EMBER_TC_REQUESTER_VERIFY_KEY_FAILURE = 0x33, - EMBER_TC_REQUESTER_VERIFY_KEY_SUCCESS = 0x34, - - // These are status values applying only to the key requester - // verifying link keys. - EMBER_VERIFY_LINK_KEY_FAILURE = 0x64, - EMBER_VERIFY_LINK_KEY_SUCCESS = 0x65, + EMBER_KEY_STATUS_NONE = 0x00, + EMBER_APP_LINK_KEY_ESTABLISHED = 0x01, + EMBER_TRUST_CENTER_LINK_KEY_ESTABLISHED = 0x03, + + EMBER_KEY_ESTABLISHMENT_TIMEOUT = 0x04, + EMBER_KEY_TABLE_FULL = 0x05, + + // These are success status values applying only to the + // Trust Center answering key requests. + EMBER_TC_RESPONDED_TO_KEY_REQUEST = 0x06, + EMBER_TC_APP_KEY_SENT_TO_REQUESTER = 0x07, + + // These are failure status values applying only to the + // Trust Center answering key requests. + EMBER_TC_RESPONSE_TO_KEY_REQUEST_FAILED = 0x08, + EMBER_TC_REQUEST_KEY_TYPE_NOT_SUPPORTED = 0x09, + EMBER_TC_NO_LINK_KEY_FOR_REQUESTER = 0x0A, + EMBER_TC_REQUESTER_EUI64_UNKNOWN = 0x0B, + EMBER_TC_RECEIVED_FIRST_APP_KEY_REQUEST = 0x0C, + EMBER_TC_TIMEOUT_WAITING_FOR_SECOND_APP_KEY_REQUEST = 0x0D, + EMBER_TC_NON_MATCHING_APP_KEY_REQUEST_RECEIVED = 0x0E, + EMBER_TC_FAILED_TO_SEND_APP_KEYS = 0x0F, + EMBER_TC_FAILED_TO_STORE_APP_KEY_REQUEST = 0x10, + EMBER_TC_REJECTED_APP_KEY_REQUEST = 0x11, + EMBER_TC_FAILED_TO_GENERATE_NEW_KEY = 0x12, + EMBER_TC_FAILED_TO_SEND_TC_KEY = 0x13, + + // These are generic status values for a key requester. + EMBER_TRUST_CENTER_IS_PRE_R21 = 0x1E, + + // These are status values applying only to the Trust Center + // verifying link keys. + EMBER_TC_REQUESTER_VERIFY_KEY_TIMEOUT = 0x32, + EMBER_TC_REQUESTER_VERIFY_KEY_FAILURE = 0x33, + EMBER_TC_REQUESTER_VERIFY_KEY_SUCCESS = 0x34, + + // These are status values applying only to the key requester + // verifying link keys. + EMBER_VERIFY_LINK_KEY_FAILURE = 0x64, + EMBER_VERIFY_LINK_KEY_SUCCESS = 0x65, }; typedef uint8_t EmberAfPluginNetworkSteeringJoiningState; @@ -766,7 +768,7 @@ typedef uint8_t SleepModes; enum #endif { - SLEEPMODE_IDLE = 1, + SLEEPMODE_IDLE = 1, }; /** @@ -779,17 +781,17 @@ typedef uint8_t EmberNetworkStatus; enum #endif { - /** The node is not associated with a network in any way. */ - EMBER_NO_NETWORK, - /** The node is currently attempting to join a network. */ - EMBER_JOINING_NETWORK, - /** The node is joined to a network. */ - EMBER_JOINED_NETWORK, - /** The node is an end device joined to a network but its parent - is not responding. */ - EMBER_JOINED_NETWORK_NO_PARENT, - /** The node is in the process of leaving its current network. */ - EMBER_LEAVING_NETWORK + /** The node is not associated with a network in any way. */ + EMBER_NO_NETWORK, + /** The node is currently attempting to join a network. */ + EMBER_JOINING_NETWORK, + /** The node is joined to a network. */ + EMBER_JOINED_NETWORK, + /** The node is an end device joined to a network but its parent + is not responding. */ + EMBER_JOINED_NETWORK_NO_PARENT, + /** The node is in the process of leaving its current network. */ + EMBER_LEAVING_NETWORK }; /** @brief Holds network parameters. @@ -798,38 +800,39 @@ enum * see the technical specification for the * RF communication module in your Developer Kit. */ -typedef struct { - /** The network's extended PAN identifier.*/ - uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; - /** The network's PAN identifier.*/ - uint16_t panId; - /** A power setting, in dBm.*/ - int8_t radioTxPower; - /** A radio channel. Be sure to specify a channel supported by the radio. */ - uint8_t radioChannel; - /** Join method: The protocol messages used to establish an initial parent. It is - * ignored when forming a ZigBee network, or when querying the stack for its - network parameters. - */ - EmberJoinMethod joinMethod; - - /** NWK Manager ID. The ID of the network manager in the current network. - This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE - as the join method. - */ - EmberNodeId nwkManagerId; - /** An NWK Update ID. The value of the ZigBee nwkUpdateId known by the stack. - It is used to determine the newest instance of the network after a PAN - ID or channel change. This may only be set at joining when using - EMBER_USE_CONFIGURED_NWK_STATE as the join method. - */ - uint8_t nwkUpdateId; - /** The NWK channel mask. The list of preferred channels that the NWK manager - has told this device to use when searching for the network. - This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE - as the join method. - */ - uint32_t channels; +typedef struct +{ + /** The network's extended PAN identifier.*/ + uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE]; + /** The network's PAN identifier.*/ + uint16_t panId; + /** A power setting, in dBm.*/ + int8_t radioTxPower; + /** A radio channel. Be sure to specify a channel supported by the radio. */ + uint8_t radioChannel; + /** Join method: The protocol messages used to establish an initial parent. It is + * ignored when forming a ZigBee network, or when querying the stack for its + network parameters. + */ + EmberJoinMethod joinMethod; + + /** NWK Manager ID. The ID of the network manager in the current network. + This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE + as the join method. + */ + EmberNodeId nwkManagerId; + /** An NWK Update ID. The value of the ZigBee nwkUpdateId known by the stack. + It is used to determine the newest instance of the network after a PAN + ID or channel change. This may only be set at joining when using + EMBER_USE_CONFIGURED_NWK_STATE as the join method. + */ + uint8_t nwkUpdateId; + /** The NWK channel mask. The list of preferred channels that the NWK manager + has told this device to use when searching for the network. + This may only be set at joining when using EMBER_USE_CONFIGURED_NWK_STATE + as the join method. + */ + uint32_t channels; } EmberNetworkParameters; /** @@ -846,36 +849,38 @@ typedef uint8_t EmberMessageBuffer; /** * @brief A version structure containing all version information. */ -typedef struct { - uint16_t build; - uint8_t major; - uint8_t minor; - uint8_t patch; - uint8_t special; - EmberVersionType type; +typedef struct +{ + uint16_t build; + uint8_t major; + uint8_t minor; + uint8_t patch; + uint8_t special; + EmberVersionType type; } EmberVersion; /** @brief This structure contains information about child nodes. * */ -typedef struct { - EmberEUI64 eui64; - EmberNodeType type; - EmberNodeId id; - uint8_t phy; - uint8_t power; - uint8_t timeout; +typedef struct +{ + EmberEUI64 eui64; + EmberNodeType type; + EmberNodeId id; + uint8_t phy; + uint8_t power; + uint8_t timeout; } EmberChildData; /** * @brief The profile ID used to address all the public profiles. */ -#define EMBER_WILDCARD_PROFILE_ID 0xFFFF +#define EMBER_WILDCARD_PROFILE_ID 0xFFFF /** * @brief The maximum value for a profile ID in the standard profile range. */ -#define EMBER_MAXIMUM_STANDARD_PROFILE_ID 0x7FFF +#define EMBER_MAXIMUM_STANDARD_PROFILE_ID 0x7FFF /** * @brief A distinguished network ID that will never be assigned @@ -884,912 +889,912 @@ typedef struct { * or binding table entry is currently in use but the node ID * corresponding to the EUI64 in the table is currently unknown. */ -#define EMBER_UNKNOWN_NODE_ID 0xFFFD +#define EMBER_UNKNOWN_NODE_ID 0xFFFD #ifdef DOXYGEN_SHOULD_SKIP_THIS enum EmberStatus #else typedef uint8_t EmberStatus; enum -#endif //DOXYGEN_SHOULD_SKIP_THIS +#endif // DOXYGEN_SHOULD_SKIP_THIS { -/** - * @name Generic Messages - * These messages are system wide. - */ -//@{ - -/** - * @brief The generic "no error" message. - */ - EMBER_SUCCESS = 0x00, - -/** - * @brief The generic "fatal error" message. - */ - EMBER_ERR_FATAL = 0x01, - -/** - * @brief An invalid value was passed as an argument to a function. - */ - EMBER_BAD_ARGUMENT = 0x02, - -/** - * @brief The requested information was not found. - */ - EMBER_NOT_FOUND = 0x03, - -/** - * @brief The manufacturing and stack token format in non-volatile memory - * is different than what the stack expects (returned at initialization). - */ - EMBER_EEPROM_MFG_STACK_VERSION_MISMATCH = 0x04, - -/** - * @brief The static memory definitions in ember-static-memory.h - * are incompatible with this stack version. - */ - EMBER_INCOMPATIBLE_STATIC_MEMORY_DEFINITIONS = 0x05, - -/** - * @brief The manufacturing token format in non-volatile memory is - * different than what the stack expects (returned at initialization). - */ - EMBER_EEPROM_MFG_VERSION_MISMATCH = 0x06, - -/** - * @brief The stack token format in non-volatile memory is different - * than what the stack expects (returned at initialization). - */ - EMBER_EEPROM_STACK_VERSION_MISMATCH = 0x07, - -//@} // END Generic Messages - -/** - * @name Packet Buffer Module Errors - */ -//@{ - -/** - * @brief There are no more buffers. - */ - EMBER_NO_BUFFERS = 0x18, - -//@} / END Packet Buffer Module Errors - -/** - * @name Serial Manager Errors - */ -//@{ - -/** - * @brief Specifies an invalid baud rate. - */ - EMBER_SERIAL_INVALID_BAUD_RATE = 0x20, - -/** - * @brief Specifies an invalid serial port. - */ - EMBER_SERIAL_INVALID_PORT = 0x21, - -/** - * @brief Tried to send too much data. - */ - EMBER_SERIAL_TX_OVERFLOW = 0x22, - -/** - * @brief There wasn't enough space to store a received character - * and the character was dropped. - */ - EMBER_SERIAL_RX_OVERFLOW = 0x23, - -/** - * @brief Detected a UART framing error. - */ - EMBER_SERIAL_RX_FRAME_ERROR = 0x24, - -/** - * @brief Detected a UART parity error. - */ - EMBER_SERIAL_RX_PARITY_ERROR = 0x25, - -/** - * @brief There is no received data to process. - */ - EMBER_SERIAL_RX_EMPTY = 0x26, - -/** - * @brief The receive interrupt was not handled in time and a - * character was dropped. - */ - EMBER_SERIAL_RX_OVERRUN_ERROR = 0x27, - -//@} - -/** - * @name MAC Errors - */ -//@{ - -/** - * @brief The MAC transmit queue is full. - */ - EMBER_MAC_TRANSMIT_QUEUE_FULL = 0x39, -// Internal - -/** - * @brief MAC header FCF error on receive. - */ - EMBER_MAC_UNKNOWN_HEADER_TYPE = 0x3A, - -/** - * @brief MAC ACK header received. - */ - EMBER_MAC_ACK_HEADER_TYPE = 0x3B, - -/** - * @brief The MAC can't complete this task because it is scanning. - */ - EMBER_MAC_SCANNING = 0x3D, - -/** - * @brief No pending data exists for a data poll. - */ - EMBER_MAC_NO_DATA = 0x31, - -/** - * @brief Attempts to scan when joined to a network. - */ - EMBER_MAC_JOINED_NETWORK = 0x32, - -/** - * @brief Scan duration must be 0 to 14 inclusive. Tried to - * scan with an incorrect duration value. - */ - EMBER_MAC_BAD_SCAN_DURATION = 0x33, - -/** - * @brief emberStartScan was called with an incorrect scan type. - */ - EMBER_MAC_INCORRECT_SCAN_TYPE = 0x34, - -/** - * @brief emberStartScan was called with an invalid channel mask. - */ - EMBER_MAC_INVALID_CHANNEL_MASK = 0x35, - -/** - * @brief Failed to scan the current channel because - * the relevant MAC command could not be transmitted. - */ - EMBER_MAC_COMMAND_TRANSMIT_FAILURE = 0x36, - -/** - * @brief An ACK was expected following the transmission but - * the MAC level ACK was never received. - */ - EMBER_MAC_NO_ACK_RECEIVED = 0x40, - -/** - * @brief MAC failed to transmit a message because it could not successfully - * perform a radio network switch. - */ - EMBER_MAC_RADIO_NETWORK_SWITCH_FAILED = 0x41, - -/** - * @brief An indirect data message timed out before a poll requested it. - */ - EMBER_MAC_INDIRECT_TIMEOUT = 0x42, - -//@} - -/** - * @name Simulated EEPROM Errors - */ -//@{ - -/** - * @brief The Simulated EEPROM is telling the application that - * at least one flash page to be erased. The GREEN status means the - * current page has not filled above the ::ERASE_CRITICAL_THRESHOLD. - * - * The application should call the function ::halSimEepromErasePage() - * when it can to erase a page. - */ - EMBER_SIM_EEPROM_ERASE_PAGE_GREEN = 0x43, - -/** - * @brief The Simulated EEPROM is telling the application that - * at least one flash page must be erased. The RED status means the - * current page has filled above the ::ERASE_CRITICAL_THRESHOLD. - * - * Due to the shrinking availability of write space, data could - * be lost. The application must call the function ::halSimEepromErasePage() - * as soon as possible to erase a page. - */ - EMBER_SIM_EEPROM_ERASE_PAGE_RED = 0x44, - -/** - * @brief The Simulated EEPROM has run out of room to write new data - * and the data trying to be set has been lost. This error code is the - * result of ignoring the ::SIM_EEPROM_ERASE_PAGE_RED error code. - * - * The application must call the function ::halSimEepromErasePage() to make room for - * any further calls to set a token. - */ - EMBER_SIM_EEPROM_FULL = 0x45, - -// Errors 46 and 47 are now defined below in the -// flash error block (was attempting to prevent renumbering). - -/** - * @brief Attempt 1 to initialize the Simulated EEPROM has failed. - * - * This failure means the information already stored in the Flash (or a lack - * thereof), is fatally incompatible with the token information compiled - * into the code image being run. - */ - EMBER_SIM_EEPROM_INIT_1_FAILED = 0x48, - -/** - * @brief Attempt 2 to initialize the Simulated EEPROM has failed. - * - * This failure means Attempt 1 failed, and the token system failed to - * properly reload default tokens and reset the Simulated EEPROM. - */ - EMBER_SIM_EEPROM_INIT_2_FAILED = 0x49, - -/** - * @brief Attempt 3 to initialize the Simulated EEPROM has failed. - * - * This failure means one or both of the tokens ::TOKEN_MFG_NVDATA_VERSION or - * ::TOKEN_STACK_NVDATA_VERSION were incorrect and the token system failed to - * properly reload default tokens and reset the Simulated EEPROM. - */ - EMBER_SIM_EEPROM_INIT_3_FAILED = 0x4A, - -/** - * @brief The Simulated EEPROM is repairing itself. - * - * While there's nothing for an app to do when the SimEE is going to - * repair itself (SimEE has to be fully functional for the rest of the - * system to work), alert the application to the fact that repair - * is occurring. There are debugging scenarios where an app might want - * to know that repair is happening, such as monitoring frequency. - * @note Common situations will trigger an expected repair, such as - * using an erased chip or changing token definitions. - */ - EMBER_SIM_EEPROM_REPAIRING = 0x4D, - -//@} - -/** - * @name Flash Errors - */ -//@{ - -/** - * @brief A fatal error has occurred while trying to write data to the - * Flash. The target memory attempting to be programmed is already programmed. - * The flash write routines were asked to flip a bit from a 0 to 1, which is - * physically impossible and the write was therefore inhibited. The data in - * the Flash cannot be trusted after this error. - */ - EMBER_ERR_FLASH_WRITE_INHIBITED = 0x46, - -/** - * @brief A fatal error has occurred while trying to write data to the - * Flash and the write verification has failed. Data in the Flash - * cannot be trusted after this error and it is possible this error is the - * result of exceeding the life cycles of the Flash. - */ - EMBER_ERR_FLASH_VERIFY_FAILED = 0x47, - -/** - * @description A fatal error has occurred while trying to write data to the - * Flash possibly due to write protection or an invalid address. Data in - * the Flash cannot be trusted after this error and it is possible this error - * is the result of exceeding the life cycles of the Flash. - */ - EMBER_ERR_FLASH_PROG_FAIL = 0x4B, - -/** - * @description A fatal error has occurred while trying to erase the Flash possibly - * due to write protection. Data in the Flash cannot be trusted after - * this error and it is possible this error is the result of exceeding the - * life cycles of the Flash. - */ - EMBER_ERR_FLASH_ERASE_FAIL = 0x4C, - -//@} - -/** - * @name Bootloader Errors - */ -//@{ - -/** - * @brief The bootloader received an invalid message (failed attempt - * to go into bootloader). - */ - EMBER_ERR_BOOTLOADER_TRAP_TABLE_BAD = 0x58, - -/** - * @brief The bootloader received an invalid message (failed attempt to go - * into the bootloader). - */ - EMBER_ERR_BOOTLOADER_TRAP_UNKNOWN = 0x59, - -/** - * @brief The bootloader cannot complete the bootload operation because - * either an image was not found or the image exceeded memory bounds. - */ - EMBER_ERR_BOOTLOADER_NO_IMAGE = 0x05A, - -//@} - -/** - * @name Transport Errors - */ -//@{ - -/** - * @brief The APS layer attempted to send or deliver a message - * and failed. - */ - EMBER_DELIVERY_FAILED = 0x66, - -/** - * @brief This binding index is out of range for the current binding table. - */ - EMBER_BINDING_INDEX_OUT_OF_RANGE = 0x69, - -/** - * @brief This address table index is out of range for the current - * address table. - */ - EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE = 0x6A, - -/** - * @brief An invalid binding table index was given to a function. - */ - EMBER_INVALID_BINDING_INDEX = 0x6C, - -/** - * @brief The API call is not allowed given the current state of the - * stack. - */ - EMBER_INVALID_CALL = 0x70, - -/** - * @brief The link cost to a node is not known. - */ - EMBER_COST_NOT_KNOWN = 0x71, - -/** - * @brief The maximum number of in-flight messages = i.e., - * ::EMBER_APS_UNICAST_MESSAGE_COUNT, has been reached. - */ - EMBER_MAX_MESSAGE_LIMIT_REACHED = 0x72, - -/** - * @brief The message to be transmitted is too big to fit into a - * single over-the-air packet. - */ - EMBER_MESSAGE_TOO_LONG = 0x74, - -/** - * @brief The application is trying to delete or overwrite a binding - * that is in use. - */ - EMBER_BINDING_IS_ACTIVE = 0x75, - -/** - * @brief The application is trying to overwrite an address table entry - * that is in use. - */ - EMBER_ADDRESS_TABLE_ENTRY_IS_ACTIVE = 0x76, - -/** - * @brief An attempt was made to transmit during the suspend period. - */ - EMBER_TRANSMISSION_SUSPENDED = 0x77, - -//@} -// - -/** - * @name Green Power status codes - */ -//@{ - -/** - * @brief Security match. - */ - EMBER_MATCH = 0x78, -/** - * @brief Drop frame. - */ - EMBER_DROP_FRAME = 0x79, -/** - * @brief - */ - EMBER_PASS_UNPROCESSED = 0x7A, -/** - * @brief - */ - EMBER_TX_THEN_DROP = 0x7B, -/** - * @brief - */ - EMBER_NO_SECURITY = 0x7C, -/** - * @brief - */ - EMBER_COUNTER_FAILURE = 0x7D, -/** - * @brief - */ - EMBER_AUTH_FAILURE = 0x7E, -/** - * @brief - */ - EMBER_UNPROCESSED = 0x7F, - -//@} -// - -/** - * @name HAL Module Errors - */ -//@{ - -/** - * @brief The conversion is complete. - */ - EMBER_ADC_CONVERSION_DONE = 0x80, - -/** - * @brief The conversion cannot be done because a request is being - * processed. - */ - EMBER_ADC_CONVERSION_BUSY = 0x81, - -/** - * @brief The conversion is deferred until the current request has been - * processed. - */ - EMBER_ADC_CONVERSION_DEFERRED = 0x82, - -/** - * @brief No results are pending. - */ - EMBER_ADC_NO_CONVERSION_PENDING = 0x84, - -/** - * @brief Sleeping (for a duration) has been abnormally interrupted - * and exited prematurely. - */ - EMBER_SLEEP_INTERRUPTED = 0x85, - -//@} - -/** - * @name PHY Errors - */ -//@{ - -/** - * @brief The transmit attempt failed because the radio scheduler could not find - * a slot to transmit this packet in or a higher priority event interrupted it. - */ - EMBER_PHY_TX_SCHED_FAIL = 0x87, - -/** - * @brief The transmit hardware buffer underflowed. - */ - EMBER_PHY_TX_UNDERFLOW = 0x88, - -/** - * @brief The transmit hardware did not finish transmitting a packet. - */ - EMBER_PHY_TX_INCOMPLETE = 0x89, - -/** - * @brief An unsupported channel setting was specified. - */ - EMBER_PHY_INVALID_CHANNEL = 0x8A, - -/** - * @brief An unsupported power setting was specified. - */ - EMBER_PHY_INVALID_POWER = 0x8B, - -/** - * @brief The requested operation cannot be completed because the radio - * is currently busy, either transmitting a packet or performing calibration. - */ - EMBER_PHY_TX_BUSY = 0x8C, - -/** - * @brief The transmit attempt failed because all CCA attempts indicated that - * the channel was busy. - */ - EMBER_PHY_TX_CCA_FAIL = 0x8D, - -/** - * @brief The transmit attempt was blocked from going over the air. Typically - * this is due to the Radio Hold Off (RHO) or Coexistence plugins as they can - * prevent transmits based on external signals. - */ - EMBER_PHY_TX_BLOCKED = 0x8E, - -/** - * @brief The expected ACK was received after the last transmission. - */ - EMBER_PHY_ACK_RECEIVED = 0x8F, - -//@} - -/** - * @name Return Codes Passed to emberStackStatusHandler() - * See also ::emberStackStatusHandler = ,. - */ -//@{ - -/** - * @brief The stack software has completed initialization and is ready - * to send and receive packets over the air. - */ - EMBER_NETWORK_UP = 0x90, - -/** - * @brief The network is not operating. - */ - EMBER_NETWORK_DOWN = 0x91, - -/** - * @brief An attempt to join a network failed. - */ - EMBER_JOIN_FAILED = 0x94, - -/** - * @brief After moving, a mobile node's attempt to re-establish contact - * with the network failed. - */ - EMBER_MOVE_FAILED = 0x96, - -/** - * @brief An attempt to join as a router failed due to a Zigbee - * versus Zigbee Pro incompatibility. Zigbee devices joining Zigbee Pro networks - * (or vice versa) must join as End Devices, not Routers. - */ - EMBER_CANNOT_JOIN_AS_ROUTER = 0x98, - -/** @brief The local node ID has changed. The application can get the new - * node ID by calling ::emberGetNodeId(). - */ - EMBER_NODE_ID_CHANGED = 0x99, - -/** @brief The local PAN ID has changed. The application can get the new PAN - * ID by calling ::emberGetPanId(). - */ - EMBER_PAN_ID_CHANGED = 0x9A, - -/** @brief The channel has changed. - */ - EMBER_CHANNEL_CHANGED = 0x9B, - -/** @brief An attempt to join or rejoin the network failed because - * no router beacons could be heard by the joining node. - */ - EMBER_NO_BEACONS = 0xAB, - -/** @brief An attempt was made to join a Secured Network using a pre-configured - * key, but the Trust Center sent back a Network Key in-the-clear when - * an encrypted Network Key was required. (::EMBER_REQUIRE_ENCRYPTED_KEY). - */ - EMBER_RECEIVED_KEY_IN_THE_CLEAR = 0xAC, - -/** @brief An attempt was made to join a Secured Network, but the device did - * not receive a Network Key. - */ - EMBER_NO_NETWORK_KEY_RECEIVED = 0xAD, - -/** @brief After a device joined a Secured Network, a Link Key was requested - * (::EMBER_GET_LINK_KEY_WHEN_JOINING) but no response was ever received. - */ - EMBER_NO_LINK_KEY_RECEIVED = 0xAE, - -/** @brief An attempt was made to join a Secured Network without a - * pre-configured key, but the Trust Center sent encrypted data using a - * pre-configured key. - */ - EMBER_PRECONFIGURED_KEY_REQUIRED = 0xAF, - -//@} - -/** - * @name Security Errors - */ -/** - * @brief The passed key data is not valid. A key of all zeros or - * all F's are reserved values and cannot be used. - */ - EMBER_KEY_INVALID = 0xB2, - -/** - * @brief The chosen security level (the value of ::EMBER_SECURITY_LEVEL) - * is not supported by the stack. - */ - EMBER_INVALID_SECURITY_LEVEL = 0x95, - -/** - * @brief An error occurred when trying to encrypt at the APS Level. - * - * In order to APS encrypt an outgoing packet, the sender - * needs to know the EUI64 of the destination. This error occurs because - * the EUI64 of the destination can't be determined from - * the short address (no entry in the neighbor, child, binding - * or address tables). - * - * Everytime this error code is seen, note that the stack initiates an - * IEEE address discovery request behind the scenes. Responses - * to the request are stored in the trust center cache portion of the - * address table. Note that you need at least 1 entry allocated for - * TC cache in the address table plugin. Depending on the available rows in - * the table, newly discovered addresses may replace old ones. The address - * table plugin is enabled by default on the host. If you are using an SoC - * platform, please be sure to add the address table plugin. - * - * When customers choose to send APS messages by using short addresses, - * they should incorporate a retry mechanism and try again, no sooner than - * 2 seconds later, to resend the APS message. If the app always - * receives 0xBE (EMBER_IEEE_ADDR_DISCOVERY_IN_PROGRESS) after - * multiple retries, that might indicate that: - * a) destination node is not on the network - * b) there are problems with the health of the network - * c) there may not be any space set asidein the address table for - * the newly discovered address - this can be rectified by reserving - * more entries for the trust center cache in the address table plugin - */ - EMBER_IEEE_ADDRESS_DISCOVERY_IN_PROGRESS = 0xBE, -/** - * @brief An error occurred when trying to encrypt at the APS Level. - * - * This error occurs either because the long address of the recipient can't be - * determined from the short address (no entry in the binding table) - * or there is no link key entry in the table associated with the destination, - * or there was a failure to load the correct key into the encryption core. - */ - EMBER_APS_ENCRYPTION_ERROR = 0xA6, - -/** @brief There was an attempt to form or join a network with security - * without calling ::emberSetInitialSecurityState() first. - */ - EMBER_SECURITY_STATE_NOT_SET = 0xA8, - -/** @brief There was an attempt to set an entry in the key table using - * an invalid long address. Invalid addresses include: - * - The local device's IEEE address - * - Trust Center's IEEE address - * - An existing table entry's IEEE address - * - An address consisting of all zeros or all F's - */ - EMBER_KEY_TABLE_INVALID_ADDRESS = 0xB3, - -/** @brief There was an attempt to set a security configuration that - * is not valid given the other security settings. - */ - EMBER_SECURITY_CONFIGURATION_INVALID = 0xB7, - -/** @brief There was an attempt to broadcast a key switch too quickly after - * broadcasting the next network key. The Trust Center must wait at - * least a period equal to the broadcast timeout so that all routers - * have a chance to receive the broadcast of the new network key. - */ - EMBER_TOO_SOON_FOR_SWITCH_KEY = 0xB8, - -/** @brief The received signature corresponding to the message that was passed - to the CBKE Library failed verification and is not valid. - */ - EMBER_SIGNATURE_VERIFY_FAILURE = 0xB9, - -/** @brief The message could not be sent because the link key corresponding - to the destination is not authorized for use in APS data messages. - APS Commands (sent by the stack) are allowed. To use it for encryption - of APS data messages it must be authorized using a key agreement protocol - (such as CBKE). - */ - EMBER_KEY_NOT_AUTHORIZED = 0xBB, - -/** @brief The security data provided was not valid, or an - * integrity check failed. - */ - EMBER_SECURITY_DATA_INVALID = 0xBD, - -//@} - -/** - * @name Miscellaneous Network Errors - */ -//@{ - -/** - * @brief The node has not joined a network. - */ - EMBER_NOT_JOINED = 0x93, - -/** - * @brief A message cannot be sent because the network is currently - * overloaded. - */ - EMBER_NETWORK_BUSY = 0xA1, - -/** - * @brief The application tried to send a message using an - * endpoint that it has not defined. - */ - EMBER_INVALID_ENDPOINT = 0xA3, - -/** - * @brief The application tried to use a binding that has been remotely - * modified and the change has not yet been reported to the application. - */ - EMBER_BINDING_HAS_CHANGED = 0xA4, - -/** - * @brief An attempt to generate random bytes failed because of - * insufficient random data from the radio. - */ - EMBER_INSUFFICIENT_RANDOM_DATA = 0xA5, - -/** A Zigbee route error command frame was received indicating - * that a source routed message from this node failed en route. - */ - EMBER_SOURCE_ROUTE_FAILURE = 0xA9, - -/** A Zigbee route error command frame was received indicating - * that a message sent to this node along a many-to-one route - * failed en route. The route error frame was delivered by - * an ad-hoc search for a functioning route. - */ - EMBER_MANY_TO_ONE_ROUTE_FAILURE = 0xAA, - -//@} - -/** - * @name Miscellaneous Utility Errors - */ -//@{ - -/** - * @brief A critical and fatal error indicating that the version of the - * stack trying to run does not match with the chip it's running on. The - * software (stack) on the chip must be replaced with software - * compatible with the chip. - */ - EMBER_STACK_AND_HARDWARE_MISMATCH = 0xB0, - -/** - * @brief An index was passed into the function that was larger - * than the valid range. - */ - EMBER_INDEX_OUT_OF_RANGE = 0xB1, - -/** - * @brief There are no empty entries left in the table. - */ - EMBER_TABLE_FULL = 0xB4, - -/** - * @brief The requested table entry has been erased and contains - * no valid data. - */ - EMBER_TABLE_ENTRY_ERASED = 0xB6, - -/** - * @brief The requested function cannot be executed because - * the library that contains the necessary functionality is not present. - */ - EMBER_LIBRARY_NOT_PRESENT = 0xB5, - -/** - * @brief The stack accepted the command and is currently processing - * the request. The results will be returned via an appropriate handler. - */ - EMBER_OPERATION_IN_PROGRESS = 0xBA, - -/** - * @brief The EUI of the Trust center has changed due to a successful rejoin. - * The device may need to perform other authentication to verify the new TC - * is authorized to take over. - */ - EMBER_TRUST_CENTER_EUI_HAS_CHANGED = 0xBC, - -//@} - -/** - * @name NVM3 Token Errors - */ -//@{ - -/** - * @brief NVM3 is telling the application that the initialization was aborted - * as no valid NVM3 page was found. - */ - EMBER_NVM3_TOKEN_NO_VALID_PAGES = 0xC0, - -/** - * @brief NVM3 is telling the application that the initialization was aborted - * as the NVM3 instance was already opened with other parameters. - */ - EMBER_NVM3_ERR_OPENED_WITH_OTHER_PARAMETERS = 0xC1, - -/** - * @brief NVM3 is telling the application that the initialization was aborted - * as the NVM3 instance is not aligned properly in memory. - */ - EMBER_NVM3_ERR_ALIGNMENT_INVALID = 0xC2, - -/** - * @brief NVM3 is telling the application that the initialization was aborted - * as the size of the NVM3 instance is too small. - */ - EMBER_NVM3_ERR_SIZE_TOO_SMALL = 0xC3, - -/** - * @brief NVM3 is telling the application that the initialization was aborted - * as the NVM3 page size is not supported. - */ - EMBER_NVM3_ERR_PAGE_SIZE_NOT_SUPPORTED = 0xC4, - -/** - * @brief NVM3 is telling the application that there was an error initializing - * some of the tokens. - */ - EMBER_NVM3_ERR_TOKEN_INIT = 0xC5, - -/** - * @brief NVM3 is telling the application there has been an error when - * attempting to upgrade SimEE tokens. - */ - EMBER_NVM3_ERR_UPGRADE = 0xC6, - -/** - * @brief NVM3 is telling the application that there has been an unknown - * error. - */ - EMBER_NVM3_ERR_UNKNOWN = 0xC7, - -//@} - -/** - * @name Application Errors - * These error codes are available for application use. - */ -//@{ - -/** - * @brief This error is reserved for customer application use. - * This will never be returned from any portion of the network stack or HAL. - */ - EMBER_APPLICATION_ERROR_0 = 0xF0, - EMBER_APPLICATION_ERROR_1 = 0xF1, - EMBER_APPLICATION_ERROR_2 = 0xF2, - EMBER_APPLICATION_ERROR_3 = 0xF3, - EMBER_APPLICATION_ERROR_4 = 0xF4, - EMBER_APPLICATION_ERROR_5 = 0xF5, - EMBER_APPLICATION_ERROR_6 = 0xF6, - EMBER_APPLICATION_ERROR_7 = 0xF7, - EMBER_APPLICATION_ERROR_8 = 0xF8, - EMBER_APPLICATION_ERROR_9 = 0xF9, - EMBER_APPLICATION_ERROR_10 = 0xFA, - EMBER_APPLICATION_ERROR_11 = 0xFB, - EMBER_APPLICATION_ERROR_12 = 0xFC, - EMBER_APPLICATION_ERROR_13 = 0xFD, - EMBER_APPLICATION_ERROR_14 = 0xFE, - EMBER_APPLICATION_ERROR_15 = 0xFF, + /** + * @name Generic Messages + * These messages are system wide. + */ + //@{ + + /** + * @brief The generic "no error" message. + */ + EMBER_SUCCESS = 0x00, + + /** + * @brief The generic "fatal error" message. + */ + EMBER_ERR_FATAL = 0x01, + + /** + * @brief An invalid value was passed as an argument to a function. + */ + EMBER_BAD_ARGUMENT = 0x02, + + /** + * @brief The requested information was not found. + */ + EMBER_NOT_FOUND = 0x03, + + /** + * @brief The manufacturing and stack token format in non-volatile memory + * is different than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_MFG_STACK_VERSION_MISMATCH = 0x04, + + /** + * @brief The static memory definitions in ember-static-memory.h + * are incompatible with this stack version. + */ + EMBER_INCOMPATIBLE_STATIC_MEMORY_DEFINITIONS = 0x05, + + /** + * @brief The manufacturing token format in non-volatile memory is + * different than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_MFG_VERSION_MISMATCH = 0x06, + + /** + * @brief The stack token format in non-volatile memory is different + * than what the stack expects (returned at initialization). + */ + EMBER_EEPROM_STACK_VERSION_MISMATCH = 0x07, + + //@} // END Generic Messages + + /** + * @name Packet Buffer Module Errors + */ + //@{ + + /** + * @brief There are no more buffers. + */ + EMBER_NO_BUFFERS = 0x18, + + //@} / END Packet Buffer Module Errors + + /** + * @name Serial Manager Errors + */ + //@{ + + /** + * @brief Specifies an invalid baud rate. + */ + EMBER_SERIAL_INVALID_BAUD_RATE = 0x20, + + /** + * @brief Specifies an invalid serial port. + */ + EMBER_SERIAL_INVALID_PORT = 0x21, + + /** + * @brief Tried to send too much data. + */ + EMBER_SERIAL_TX_OVERFLOW = 0x22, + + /** + * @brief There wasn't enough space to store a received character + * and the character was dropped. + */ + EMBER_SERIAL_RX_OVERFLOW = 0x23, + + /** + * @brief Detected a UART framing error. + */ + EMBER_SERIAL_RX_FRAME_ERROR = 0x24, + + /** + * @brief Detected a UART parity error. + */ + EMBER_SERIAL_RX_PARITY_ERROR = 0x25, + + /** + * @brief There is no received data to process. + */ + EMBER_SERIAL_RX_EMPTY = 0x26, + + /** + * @brief The receive interrupt was not handled in time and a + * character was dropped. + */ + EMBER_SERIAL_RX_OVERRUN_ERROR = 0x27, + + //@} + + /** + * @name MAC Errors + */ + //@{ + + /** + * @brief The MAC transmit queue is full. + */ + EMBER_MAC_TRANSMIT_QUEUE_FULL = 0x39, + // Internal + + /** + * @brief MAC header FCF error on receive. + */ + EMBER_MAC_UNKNOWN_HEADER_TYPE = 0x3A, + + /** + * @brief MAC ACK header received. + */ + EMBER_MAC_ACK_HEADER_TYPE = 0x3B, + + /** + * @brief The MAC can't complete this task because it is scanning. + */ + EMBER_MAC_SCANNING = 0x3D, + + /** + * @brief No pending data exists for a data poll. + */ + EMBER_MAC_NO_DATA = 0x31, + + /** + * @brief Attempts to scan when joined to a network. + */ + EMBER_MAC_JOINED_NETWORK = 0x32, + + /** + * @brief Scan duration must be 0 to 14 inclusive. Tried to + * scan with an incorrect duration value. + */ + EMBER_MAC_BAD_SCAN_DURATION = 0x33, + + /** + * @brief emberStartScan was called with an incorrect scan type. + */ + EMBER_MAC_INCORRECT_SCAN_TYPE = 0x34, + + /** + * @brief emberStartScan was called with an invalid channel mask. + */ + EMBER_MAC_INVALID_CHANNEL_MASK = 0x35, + + /** + * @brief Failed to scan the current channel because + * the relevant MAC command could not be transmitted. + */ + EMBER_MAC_COMMAND_TRANSMIT_FAILURE = 0x36, + + /** + * @brief An ACK was expected following the transmission but + * the MAC level ACK was never received. + */ + EMBER_MAC_NO_ACK_RECEIVED = 0x40, + + /** + * @brief MAC failed to transmit a message because it could not successfully + * perform a radio network switch. + */ + EMBER_MAC_RADIO_NETWORK_SWITCH_FAILED = 0x41, + + /** + * @brief An indirect data message timed out before a poll requested it. + */ + EMBER_MAC_INDIRECT_TIMEOUT = 0x42, + + //@} + + /** + * @name Simulated EEPROM Errors + */ + //@{ + + /** + * @brief The Simulated EEPROM is telling the application that + * at least one flash page to be erased. The GREEN status means the + * current page has not filled above the ::ERASE_CRITICAL_THRESHOLD. + * + * The application should call the function ::halSimEepromErasePage() + * when it can to erase a page. + */ + EMBER_SIM_EEPROM_ERASE_PAGE_GREEN = 0x43, + + /** + * @brief The Simulated EEPROM is telling the application that + * at least one flash page must be erased. The RED status means the + * current page has filled above the ::ERASE_CRITICAL_THRESHOLD. + * + * Due to the shrinking availability of write space, data could + * be lost. The application must call the function ::halSimEepromErasePage() + * as soon as possible to erase a page. + */ + EMBER_SIM_EEPROM_ERASE_PAGE_RED = 0x44, + + /** + * @brief The Simulated EEPROM has run out of room to write new data + * and the data trying to be set has been lost. This error code is the + * result of ignoring the ::SIM_EEPROM_ERASE_PAGE_RED error code. + * + * The application must call the function ::halSimEepromErasePage() to make room for + * any further calls to set a token. + */ + EMBER_SIM_EEPROM_FULL = 0x45, + + // Errors 46 and 47 are now defined below in the + // flash error block (was attempting to prevent renumbering). + + /** + * @brief Attempt 1 to initialize the Simulated EEPROM has failed. + * + * This failure means the information already stored in the Flash (or a lack + * thereof), is fatally incompatible with the token information compiled + * into the code image being run. + */ + EMBER_SIM_EEPROM_INIT_1_FAILED = 0x48, + + /** + * @brief Attempt 2 to initialize the Simulated EEPROM has failed. + * + * This failure means Attempt 1 failed, and the token system failed to + * properly reload default tokens and reset the Simulated EEPROM. + */ + EMBER_SIM_EEPROM_INIT_2_FAILED = 0x49, + + /** + * @brief Attempt 3 to initialize the Simulated EEPROM has failed. + * + * This failure means one or both of the tokens ::TOKEN_MFG_NVDATA_VERSION or + * ::TOKEN_STACK_NVDATA_VERSION were incorrect and the token system failed to + * properly reload default tokens and reset the Simulated EEPROM. + */ + EMBER_SIM_EEPROM_INIT_3_FAILED = 0x4A, + + /** + * @brief The Simulated EEPROM is repairing itself. + * + * While there's nothing for an app to do when the SimEE is going to + * repair itself (SimEE has to be fully functional for the rest of the + * system to work), alert the application to the fact that repair + * is occurring. There are debugging scenarios where an app might want + * to know that repair is happening, such as monitoring frequency. + * @note Common situations will trigger an expected repair, such as + * using an erased chip or changing token definitions. + */ + EMBER_SIM_EEPROM_REPAIRING = 0x4D, + + //@} + + /** + * @name Flash Errors + */ + //@{ + + /** + * @brief A fatal error has occurred while trying to write data to the + * Flash. The target memory attempting to be programmed is already programmed. + * The flash write routines were asked to flip a bit from a 0 to 1, which is + * physically impossible and the write was therefore inhibited. The data in + * the Flash cannot be trusted after this error. + */ + EMBER_ERR_FLASH_WRITE_INHIBITED = 0x46, + + /** + * @brief A fatal error has occurred while trying to write data to the + * Flash and the write verification has failed. Data in the Flash + * cannot be trusted after this error and it is possible this error is the + * result of exceeding the life cycles of the Flash. + */ + EMBER_ERR_FLASH_VERIFY_FAILED = 0x47, + + /** + * @description A fatal error has occurred while trying to write data to the + * Flash possibly due to write protection or an invalid address. Data in + * the Flash cannot be trusted after this error and it is possible this error + * is the result of exceeding the life cycles of the Flash. + */ + EMBER_ERR_FLASH_PROG_FAIL = 0x4B, + + /** + * @description A fatal error has occurred while trying to erase the Flash possibly + * due to write protection. Data in the Flash cannot be trusted after + * this error and it is possible this error is the result of exceeding the + * life cycles of the Flash. + */ + EMBER_ERR_FLASH_ERASE_FAIL = 0x4C, + + //@} + + /** + * @name Bootloader Errors + */ + //@{ + + /** + * @brief The bootloader received an invalid message (failed attempt + * to go into bootloader). + */ + EMBER_ERR_BOOTLOADER_TRAP_TABLE_BAD = 0x58, + + /** + * @brief The bootloader received an invalid message (failed attempt to go + * into the bootloader). + */ + EMBER_ERR_BOOTLOADER_TRAP_UNKNOWN = 0x59, + + /** + * @brief The bootloader cannot complete the bootload operation because + * either an image was not found or the image exceeded memory bounds. + */ + EMBER_ERR_BOOTLOADER_NO_IMAGE = 0x05A, + + //@} + + /** + * @name Transport Errors + */ + //@{ + + /** + * @brief The APS layer attempted to send or deliver a message + * and failed. + */ + EMBER_DELIVERY_FAILED = 0x66, + + /** + * @brief This binding index is out of range for the current binding table. + */ + EMBER_BINDING_INDEX_OUT_OF_RANGE = 0x69, + + /** + * @brief This address table index is out of range for the current + * address table. + */ + EMBER_ADDRESS_TABLE_INDEX_OUT_OF_RANGE = 0x6A, + + /** + * @brief An invalid binding table index was given to a function. + */ + EMBER_INVALID_BINDING_INDEX = 0x6C, + + /** + * @brief The API call is not allowed given the current state of the + * stack. + */ + EMBER_INVALID_CALL = 0x70, + + /** + * @brief The link cost to a node is not known. + */ + EMBER_COST_NOT_KNOWN = 0x71, + + /** + * @brief The maximum number of in-flight messages = i.e., + * ::EMBER_APS_UNICAST_MESSAGE_COUNT, has been reached. + */ + EMBER_MAX_MESSAGE_LIMIT_REACHED = 0x72, + + /** + * @brief The message to be transmitted is too big to fit into a + * single over-the-air packet. + */ + EMBER_MESSAGE_TOO_LONG = 0x74, + + /** + * @brief The application is trying to delete or overwrite a binding + * that is in use. + */ + EMBER_BINDING_IS_ACTIVE = 0x75, + + /** + * @brief The application is trying to overwrite an address table entry + * that is in use. + */ + EMBER_ADDRESS_TABLE_ENTRY_IS_ACTIVE = 0x76, + + /** + * @brief An attempt was made to transmit during the suspend period. + */ + EMBER_TRANSMISSION_SUSPENDED = 0x77, + + //@} + // + + /** + * @name Green Power status codes + */ + //@{ + + /** + * @brief Security match. + */ + EMBER_MATCH = 0x78, + /** + * @brief Drop frame. + */ + EMBER_DROP_FRAME = 0x79, + /** + * @brief + */ + EMBER_PASS_UNPROCESSED = 0x7A, + /** + * @brief + */ + EMBER_TX_THEN_DROP = 0x7B, + /** + * @brief + */ + EMBER_NO_SECURITY = 0x7C, + /** + * @brief + */ + EMBER_COUNTER_FAILURE = 0x7D, + /** + * @brief + */ + EMBER_AUTH_FAILURE = 0x7E, + /** + * @brief + */ + EMBER_UNPROCESSED = 0x7F, + + //@} + // + + /** + * @name HAL Module Errors + */ + //@{ + + /** + * @brief The conversion is complete. + */ + EMBER_ADC_CONVERSION_DONE = 0x80, + + /** + * @brief The conversion cannot be done because a request is being + * processed. + */ + EMBER_ADC_CONVERSION_BUSY = 0x81, + + /** + * @brief The conversion is deferred until the current request has been + * processed. + */ + EMBER_ADC_CONVERSION_DEFERRED = 0x82, + + /** + * @brief No results are pending. + */ + EMBER_ADC_NO_CONVERSION_PENDING = 0x84, + + /** + * @brief Sleeping (for a duration) has been abnormally interrupted + * and exited prematurely. + */ + EMBER_SLEEP_INTERRUPTED = 0x85, + + //@} + + /** + * @name PHY Errors + */ + //@{ + + /** + * @brief The transmit attempt failed because the radio scheduler could not find + * a slot to transmit this packet in or a higher priority event interrupted it. + */ + EMBER_PHY_TX_SCHED_FAIL = 0x87, + + /** + * @brief The transmit hardware buffer underflowed. + */ + EMBER_PHY_TX_UNDERFLOW = 0x88, + + /** + * @brief The transmit hardware did not finish transmitting a packet. + */ + EMBER_PHY_TX_INCOMPLETE = 0x89, + + /** + * @brief An unsupported channel setting was specified. + */ + EMBER_PHY_INVALID_CHANNEL = 0x8A, + + /** + * @brief An unsupported power setting was specified. + */ + EMBER_PHY_INVALID_POWER = 0x8B, + + /** + * @brief The requested operation cannot be completed because the radio + * is currently busy, either transmitting a packet or performing calibration. + */ + EMBER_PHY_TX_BUSY = 0x8C, + + /** + * @brief The transmit attempt failed because all CCA attempts indicated that + * the channel was busy. + */ + EMBER_PHY_TX_CCA_FAIL = 0x8D, + + /** + * @brief The transmit attempt was blocked from going over the air. Typically + * this is due to the Radio Hold Off (RHO) or Coexistence plugins as they can + * prevent transmits based on external signals. + */ + EMBER_PHY_TX_BLOCKED = 0x8E, + + /** + * @brief The expected ACK was received after the last transmission. + */ + EMBER_PHY_ACK_RECEIVED = 0x8F, + + //@} + + /** + * @name Return Codes Passed to emberStackStatusHandler() + * See also ::emberStackStatusHandler = ,. + */ + //@{ + + /** + * @brief The stack software has completed initialization and is ready + * to send and receive packets over the air. + */ + EMBER_NETWORK_UP = 0x90, + + /** + * @brief The network is not operating. + */ + EMBER_NETWORK_DOWN = 0x91, + + /** + * @brief An attempt to join a network failed. + */ + EMBER_JOIN_FAILED = 0x94, + + /** + * @brief After moving, a mobile node's attempt to re-establish contact + * with the network failed. + */ + EMBER_MOVE_FAILED = 0x96, + + /** + * @brief An attempt to join as a router failed due to a Zigbee + * versus Zigbee Pro incompatibility. Zigbee devices joining Zigbee Pro networks + * (or vice versa) must join as End Devices, not Routers. + */ + EMBER_CANNOT_JOIN_AS_ROUTER = 0x98, + + /** @brief The local node ID has changed. The application can get the new + * node ID by calling ::emberGetNodeId(). + */ + EMBER_NODE_ID_CHANGED = 0x99, + + /** @brief The local PAN ID has changed. The application can get the new PAN + * ID by calling ::emberGetPanId(). + */ + EMBER_PAN_ID_CHANGED = 0x9A, + + /** @brief The channel has changed. + */ + EMBER_CHANNEL_CHANGED = 0x9B, + + /** @brief An attempt to join or rejoin the network failed because + * no router beacons could be heard by the joining node. + */ + EMBER_NO_BEACONS = 0xAB, + + /** @brief An attempt was made to join a Secured Network using a pre-configured + * key, but the Trust Center sent back a Network Key in-the-clear when + * an encrypted Network Key was required. (::EMBER_REQUIRE_ENCRYPTED_KEY). + */ + EMBER_RECEIVED_KEY_IN_THE_CLEAR = 0xAC, + + /** @brief An attempt was made to join a Secured Network, but the device did + * not receive a Network Key. + */ + EMBER_NO_NETWORK_KEY_RECEIVED = 0xAD, + + /** @brief After a device joined a Secured Network, a Link Key was requested + * (::EMBER_GET_LINK_KEY_WHEN_JOINING) but no response was ever received. + */ + EMBER_NO_LINK_KEY_RECEIVED = 0xAE, + + /** @brief An attempt was made to join a Secured Network without a + * pre-configured key, but the Trust Center sent encrypted data using a + * pre-configured key. + */ + EMBER_PRECONFIGURED_KEY_REQUIRED = 0xAF, + + //@} + + /** + * @name Security Errors + */ + /** + * @brief The passed key data is not valid. A key of all zeros or + * all F's are reserved values and cannot be used. + */ + EMBER_KEY_INVALID = 0xB2, + + /** + * @brief The chosen security level (the value of ::EMBER_SECURITY_LEVEL) + * is not supported by the stack. + */ + EMBER_INVALID_SECURITY_LEVEL = 0x95, + + /** + * @brief An error occurred when trying to encrypt at the APS Level. + * + * In order to APS encrypt an outgoing packet, the sender + * needs to know the EUI64 of the destination. This error occurs because + * the EUI64 of the destination can't be determined from + * the short address (no entry in the neighbor, child, binding + * or address tables). + * + * Everytime this error code is seen, note that the stack initiates an + * IEEE address discovery request behind the scenes. Responses + * to the request are stored in the trust center cache portion of the + * address table. Note that you need at least 1 entry allocated for + * TC cache in the address table plugin. Depending on the available rows in + * the table, newly discovered addresses may replace old ones. The address + * table plugin is enabled by default on the host. If you are using an SoC + * platform, please be sure to add the address table plugin. + * + * When customers choose to send APS messages by using short addresses, + * they should incorporate a retry mechanism and try again, no sooner than + * 2 seconds later, to resend the APS message. If the app always + * receives 0xBE (EMBER_IEEE_ADDR_DISCOVERY_IN_PROGRESS) after + * multiple retries, that might indicate that: + * a) destination node is not on the network + * b) there are problems with the health of the network + * c) there may not be any space set asidein the address table for + * the newly discovered address - this can be rectified by reserving + * more entries for the trust center cache in the address table plugin + */ + EMBER_IEEE_ADDRESS_DISCOVERY_IN_PROGRESS = 0xBE, + /** + * @brief An error occurred when trying to encrypt at the APS Level. + * + * This error occurs either because the long address of the recipient can't be + * determined from the short address (no entry in the binding table) + * or there is no link key entry in the table associated with the destination, + * or there was a failure to load the correct key into the encryption core. + */ + EMBER_APS_ENCRYPTION_ERROR = 0xA6, + + /** @brief There was an attempt to form or join a network with security + * without calling ::emberSetInitialSecurityState() first. + */ + EMBER_SECURITY_STATE_NOT_SET = 0xA8, + + /** @brief There was an attempt to set an entry in the key table using + * an invalid long address. Invalid addresses include: + * - The local device's IEEE address + * - Trust Center's IEEE address + * - An existing table entry's IEEE address + * - An address consisting of all zeros or all F's + */ + EMBER_KEY_TABLE_INVALID_ADDRESS = 0xB3, + + /** @brief There was an attempt to set a security configuration that + * is not valid given the other security settings. + */ + EMBER_SECURITY_CONFIGURATION_INVALID = 0xB7, + + /** @brief There was an attempt to broadcast a key switch too quickly after + * broadcasting the next network key. The Trust Center must wait at + * least a period equal to the broadcast timeout so that all routers + * have a chance to receive the broadcast of the new network key. + */ + EMBER_TOO_SOON_FOR_SWITCH_KEY = 0xB8, + + /** @brief The received signature corresponding to the message that was passed + to the CBKE Library failed verification and is not valid. + */ + EMBER_SIGNATURE_VERIFY_FAILURE = 0xB9, + + /** @brief The message could not be sent because the link key corresponding + to the destination is not authorized for use in APS data messages. + APS Commands (sent by the stack) are allowed. To use it for encryption + of APS data messages it must be authorized using a key agreement protocol + (such as CBKE). + */ + EMBER_KEY_NOT_AUTHORIZED = 0xBB, + + /** @brief The security data provided was not valid, or an + * integrity check failed. + */ + EMBER_SECURITY_DATA_INVALID = 0xBD, + + //@} + + /** + * @name Miscellaneous Network Errors + */ + //@{ + + /** + * @brief The node has not joined a network. + */ + EMBER_NOT_JOINED = 0x93, + + /** + * @brief A message cannot be sent because the network is currently + * overloaded. + */ + EMBER_NETWORK_BUSY = 0xA1, + + /** + * @brief The application tried to send a message using an + * endpoint that it has not defined. + */ + EMBER_INVALID_ENDPOINT = 0xA3, + + /** + * @brief The application tried to use a binding that has been remotely + * modified and the change has not yet been reported to the application. + */ + EMBER_BINDING_HAS_CHANGED = 0xA4, + + /** + * @brief An attempt to generate random bytes failed because of + * insufficient random data from the radio. + */ + EMBER_INSUFFICIENT_RANDOM_DATA = 0xA5, + + /** A Zigbee route error command frame was received indicating + * that a source routed message from this node failed en route. + */ + EMBER_SOURCE_ROUTE_FAILURE = 0xA9, + + /** A Zigbee route error command frame was received indicating + * that a message sent to this node along a many-to-one route + * failed en route. The route error frame was delivered by + * an ad-hoc search for a functioning route. + */ + EMBER_MANY_TO_ONE_ROUTE_FAILURE = 0xAA, + + //@} + + /** + * @name Miscellaneous Utility Errors + */ + //@{ + + /** + * @brief A critical and fatal error indicating that the version of the + * stack trying to run does not match with the chip it's running on. The + * software (stack) on the chip must be replaced with software + * compatible with the chip. + */ + EMBER_STACK_AND_HARDWARE_MISMATCH = 0xB0, + + /** + * @brief An index was passed into the function that was larger + * than the valid range. + */ + EMBER_INDEX_OUT_OF_RANGE = 0xB1, + + /** + * @brief There are no empty entries left in the table. + */ + EMBER_TABLE_FULL = 0xB4, + + /** + * @brief The requested table entry has been erased and contains + * no valid data. + */ + EMBER_TABLE_ENTRY_ERASED = 0xB6, + + /** + * @brief The requested function cannot be executed because + * the library that contains the necessary functionality is not present. + */ + EMBER_LIBRARY_NOT_PRESENT = 0xB5, + + /** + * @brief The stack accepted the command and is currently processing + * the request. The results will be returned via an appropriate handler. + */ + EMBER_OPERATION_IN_PROGRESS = 0xBA, + + /** + * @brief The EUI of the Trust center has changed due to a successful rejoin. + * The device may need to perform other authentication to verify the new TC + * is authorized to take over. + */ + EMBER_TRUST_CENTER_EUI_HAS_CHANGED = 0xBC, + + //@} + + /** + * @name NVM3 Token Errors + */ + //@{ + + /** + * @brief NVM3 is telling the application that the initialization was aborted + * as no valid NVM3 page was found. + */ + EMBER_NVM3_TOKEN_NO_VALID_PAGES = 0xC0, + + /** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 instance was already opened with other parameters. + */ + EMBER_NVM3_ERR_OPENED_WITH_OTHER_PARAMETERS = 0xC1, + + /** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 instance is not aligned properly in memory. + */ + EMBER_NVM3_ERR_ALIGNMENT_INVALID = 0xC2, + + /** + * @brief NVM3 is telling the application that the initialization was aborted + * as the size of the NVM3 instance is too small. + */ + EMBER_NVM3_ERR_SIZE_TOO_SMALL = 0xC3, + + /** + * @brief NVM3 is telling the application that the initialization was aborted + * as the NVM3 page size is not supported. + */ + EMBER_NVM3_ERR_PAGE_SIZE_NOT_SUPPORTED = 0xC4, + + /** + * @brief NVM3 is telling the application that there was an error initializing + * some of the tokens. + */ + EMBER_NVM3_ERR_TOKEN_INIT = 0xC5, + + /** + * @brief NVM3 is telling the application there has been an error when + * attempting to upgrade SimEE tokens. + */ + EMBER_NVM3_ERR_UPGRADE = 0xC6, + + /** + * @brief NVM3 is telling the application that there has been an unknown + * error. + */ + EMBER_NVM3_ERR_UNKNOWN = 0xC7, + + //@} + + /** + * @name Application Errors + * These error codes are available for application use. + */ + //@{ + + /** + * @brief This error is reserved for customer application use. + * This will never be returned from any portion of the network stack or HAL. + */ + EMBER_APPLICATION_ERROR_0 = 0xF0, + EMBER_APPLICATION_ERROR_1 = 0xF1, + EMBER_APPLICATION_ERROR_2 = 0xF2, + EMBER_APPLICATION_ERROR_3 = 0xF3, + EMBER_APPLICATION_ERROR_4 = 0xF4, + EMBER_APPLICATION_ERROR_5 = 0xF5, + EMBER_APPLICATION_ERROR_6 = 0xF6, + EMBER_APPLICATION_ERROR_7 = 0xF7, + EMBER_APPLICATION_ERROR_8 = 0xF8, + EMBER_APPLICATION_ERROR_9 = 0xF9, + EMBER_APPLICATION_ERROR_10 = 0xFA, + EMBER_APPLICATION_ERROR_11 = 0xFB, + EMBER_APPLICATION_ERROR_12 = 0xFC, + EMBER_APPLICATION_ERROR_13 = 0xFD, + EMBER_APPLICATION_ERROR_14 = 0xFE, + EMBER_APPLICATION_ERROR_15 = 0xFF, }; /** @brief The control structure for events. @@ -1798,18 +1803,18 @@ enum * It holds the event status (one of the @e EMBER_EVENT_ values) * and the time left before the event fires. */ -typedef struct { - /** The event's status, either inactive or the units for timeToExecute. */ - EmberEventUnits status; - /** The ID of the task this event belongs to. */ - EmberTaskId taskid; - /** Indicates how long before the event fires. - * Units are milliseconds. - */ - uint32_t timeToExecute; +typedef struct +{ + /** The event's status, either inactive or the units for timeToExecute. */ + EmberEventUnits status; + /** The ID of the task this event belongs to. */ + EmberTaskId taskid; + /** Indicates how long before the event fires. + * Units are milliseconds. + */ + uint32_t timeToExecute; } EmberEventControl; - /** * @name ZigBee Broadcast Addresses *@{ @@ -1828,8 +1833,7 @@ typedef struct { * @description Useful macro for avoiding compiler warnings related to unused * function arguments or unused variables. */ -#define UNUSED_VAR(x) (void )(x) - +#define UNUSED_VAR(x) (void) (x) /** * @brief The maximum 802.15.4 channel number is 26. @@ -1844,14 +1848,12 @@ typedef struct { /** * @brief The maximum SubGhz channel number on pages 28, 30, 31 is 26. */ -#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31 26 - +#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31 26 /** * @brief The maximum SubGhz channel number on page 29 is 8. */ -#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29 8 - +#define EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29 8 /** * @brief The broadcast endpoint, as defined in the ZigBee spec. @@ -1861,66 +1863,66 @@ typedef struct { /** * @brief Friendly convenience macro pointing to the C Stdlib functions. */ - #define MEMSET(d, v, l) memset(d, v, l) - #define MEMCOPY(d, s, l) memcpy(d, s, l) - #define MEMMOVE(d, s, l) memmove(d, s, l) - #define MEMPGMCOPY(d, s, l) memcpy(d, s, l) - #define MEMCOMPARE(s0, s1, l) memcmp(s0, s1, l) - #define MEMPGMCOMPARE(s0, s1, l) memcmp(s0, s1, l) +#define MEMSET(d, v, l) memset(d, v, l) +#define MEMCOPY(d, s, l) memcpy(d, s, l) +#define MEMMOVE(d, s, l) memmove(d, s, l) +#define MEMPGMCOPY(d, s, l) memcpy(d, s, l) +#define MEMCOMPARE(s0, s1, l) memcmp(s0, s1, l) +#define MEMPGMCOMPARE(s0, s1, l) memcmp(s0, s1, l) /** * @brief Useful to reference a single bit of a byte. */ -#define BIT(x) (1U << (x)) // Unsigned avoids compiler warnings re BIT(15) +#define BIT(x) (1U << (x)) // Unsigned avoids compiler warnings re BIT(15) /** * @brief Returns the low byte of the 16-bit value \c n as an \c uint8_t. */ -#define LOW_BYTE(n) ((uint8_t)((n) & 0xFF)) +#define LOW_BYTE(n) ((uint8_t)((n) &0xFF)) /** * @brief Returns the high byte of the 16-bit value \c n as an \c uint8_t. */ -#define HIGH_BYTE(n) ((uint8_t)(LOW_BYTE((n) >> 8))) +#define HIGH_BYTE(n) ((uint8_t)(LOW_BYTE((n) >> 8))) /** * @brief Returns the low byte of the 32-bit value \c n as an \c uint8_t. */ -#define BYTE_0(n) ((uint8_t)((n) & 0xFF)) +#define BYTE_0(n) ((uint8_t)((n) &0xFF)) /** * @brief Returns the second byte of the 32-bit value \c n as an \c uint8_t. */ -#define BYTE_1(n) BYTE_0((n) >> 8) +#define BYTE_1(n) BYTE_0((n) >> 8) /** * @brief Returns the third byte of the 32-bit value \c n as an \c uint8_t. */ -#define BYTE_2(n) BYTE_0((n) >> 16) +#define BYTE_2(n) BYTE_0((n) >> 16) /** * @brief Returns the high byte of the 32-bit value \c n as an \c uint8_t. */ -#define BYTE_3(n) BYTE_0((n) >> 24) +#define BYTE_3(n) BYTE_0((n) >> 24) /** * @brief Returns the fifth byte of the 64-bit value \c n as an \c uint8_t. */ -#define BYTE_4(n) BYTE_0((n) >> 32) +#define BYTE_4(n) BYTE_0((n) >> 32) /** * @brief Returns the sixth byte of the 64-bit value \c n as an \c uint8_t. */ -#define BYTE_5(n) BYTE_0((n) >> 40) +#define BYTE_5(n) BYTE_0((n) >> 40) /** * @brief Returns the seventh byte of the 64-bit value \c n as an \c uint8_t. */ -#define BYTE_6(n) BYTE_0((n) >> 48) +#define BYTE_6(n) BYTE_0((n) >> 48) /** * @brief Returns the high byte of the 64-bit value \c n as an \c uint8_t. */ -#define BYTE_7(n) BYTE_0((n) >> 56) +#define BYTE_7(n) BYTE_0((n) >> 56) /** * @brief The kind of arguments the main function takes @@ -1931,7 +1933,7 @@ typedef struct { // Stubs to just silence some compile errors #define emberAfPrint(...) /* */ #define emberAfPrintEnabled(...) false -#define emberAfPrintln(...) /* */ +#define emberAfPrintln(...) /* */ #define emberAfPrintBuffer(...) /* */ // Needed by callback.h and callback-stubs.c diff --git a/examples/wifi-echo/server/esp32/main/util.c b/examples/wifi-echo/server/esp32/main/util.c index 35d02ee0f1267f..8f9f5a08eeba86 100644 --- a/examples/wifi-echo/server/esp32/main/util.c +++ b/examples/wifi-echo/server/esp32/main/util.c @@ -31,15 +31,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file - * @brief This file contains all of the common ZCL command and attribute handling - * code for Ember's ZCL implementation + * @brief This file contains all of the common ZCL + *command and attribute handling code for Ember's ZCL + *implementation ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ -#include "af.h" #include "af-main.h" +#include "af.h" #include "common.h" //#include "../plugin/time-server/time-server.h" //#include "app/framework/util/af-event.h" @@ -63,8 +65,8 @@ uint32_t afNumPktsSent; #endif const EmberAfClusterName zclClusterNames[] = { - CLUSTER_IDS_TO_NAMES // defined in print-cluster.h - { ZCL_NULL_CLUSTER_ID, EMBER_AF_NULL_MANUFACTURER_CODE, NULL }, // terminator + CLUSTER_IDS_TO_NAMES // defined in print-cluster.h + { ZCL_NULL_CLUSTER_ID, EMBER_AF_NULL_MANUFACTURER_CODE, NULL }, // terminator }; static const EmberAfClusterCommand staticCmd; @@ -73,7 +75,7 @@ EmberAfClusterCommand curCmd; // This struct is allocated on the stack inside // emberAfProcessMessage. The pointer below is set // to NULL when the function exits. -EmberAfClusterCommand *emAfCurrentCommand; +EmberAfClusterCommand * emAfCurrentCommand; // variable used for toggling Aps Link security. Set by the CLI uint8_t emAfTestApsSecurityOverride = APS_TEST_SECURITY_DEFAULT; @@ -91,8 +93,8 @@ uint8_t emberAfSequenceNumber = 0xFF; // key establishment. bool emAfDeviceIsPerformingKeyEstablishment = false; -static uint8_t /*enum EmberAfRetryOverride*/ emberAfApsRetryOverride = EMBER_AF_RETRY_OVERRIDE_NONE; -static uint8_t /*enum EmberAfDisableDefaultResponse*/ emAfDisableDefaultResponse = EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE; +static uint8_t /*enum EmberAfRetryOverride*/ emberAfApsRetryOverride = EMBER_AF_RETRY_OVERRIDE_NONE; +static uint8_t /*enum EmberAfDisableDefaultResponse*/ emAfDisableDefaultResponse = EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE; static uint8_t /*enum EmberAfDisableDefaultResponse*/ emAfSavedDisableDefaultResponseVale = EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE; // Holds the response type @@ -100,19 +102,15 @@ uint8_t emberAfResponseType = ZCL_UTIL_RESP_NORMAL; static EmberAfInterpanHeader interpanResponseHeader; -static const uint8_t emberAfAnalogDiscreteThresholds[] = { - 0x07, EMBER_AF_DATA_TYPE_NONE, - 0x1F, EMBER_AF_DATA_TYPE_DISCRETE, - 0x2F, EMBER_AF_DATA_TYPE_ANALOG, - 0x37, EMBER_AF_DATA_TYPE_DISCRETE, - 0x3F, EMBER_AF_DATA_TYPE_ANALOG, - 0x57, EMBER_AF_DATA_TYPE_DISCRETE, - 0xDF, EMBER_AF_DATA_TYPE_NONE, - 0xE7, EMBER_AF_DATA_TYPE_ANALOG, - 0xFF, EMBER_AF_DATA_TYPE_NONE -}; +static const uint8_t emberAfAnalogDiscreteThresholds[] = { 0x07, EMBER_AF_DATA_TYPE_NONE, 0x1F, EMBER_AF_DATA_TYPE_DISCRETE, + 0x2F, EMBER_AF_DATA_TYPE_ANALOG, 0x37, EMBER_AF_DATA_TYPE_DISCRETE, + 0x3F, EMBER_AF_DATA_TYPE_ANALOG, 0x57, EMBER_AF_DATA_TYPE_DISCRETE, + 0xDF, EMBER_AF_DATA_TYPE_NONE, 0xE7, EMBER_AF_DATA_TYPE_ANALOG, + 0xFF, EMBER_AF_DATA_TYPE_NONE }; -uint8_t emAfExtendedPanId[EXTENDED_PAN_ID_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, }; +uint8_t emAfExtendedPanId[EXTENDED_PAN_ID_SIZE] = { + 0, 0, 0, 0, 0, 0, 0, 0, +}; #ifdef EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_DECLARATIONS EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_DECLARATIONS @@ -126,37 +124,33 @@ EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_DECLARATIONS // Device enabled/disabled functions bool emberAfIsDeviceEnabled(uint8_t endpoint) { - uint8_t index; + uint8_t index; #ifdef ZCL_USING_BASIC_CLUSTER_DEVICE_ENABLED_ATTRIBUTE - bool deviceEnabled; - if (emberAfReadServerAttribute(endpoint, - ZCL_BASIC_CLUSTER_ID, - ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, - (uint8_t *)&deviceEnabled, - sizeof(deviceEnabled)) - == EMBER_ZCL_STATUS_SUCCESS) { - return deviceEnabled; - } + bool deviceEnabled; + if (emberAfReadServerAttribute(endpoint, ZCL_BASIC_CLUSTER_ID, ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, (uint8_t *) &deviceEnabled, + sizeof(deviceEnabled)) == EMBER_ZCL_STATUS_SUCCESS) + { + return deviceEnabled; + } #endif - index = emberAfIndexFromEndpoint(endpoint); - if (index != 0xFF && index < sizeof(afDeviceEnabled)) { - return afDeviceEnabled[index]; - } - return false; + index = emberAfIndexFromEndpoint(endpoint); + if (index != 0xFF && index < sizeof(afDeviceEnabled)) + { + return afDeviceEnabled[index]; + } + return false; } void emberAfSetDeviceEnabled(uint8_t endpoint, bool enabled) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index != 0xFF && index < sizeof(afDeviceEnabled)) { - afDeviceEnabled[index] = enabled; - } + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index != 0xFF && index < sizeof(afDeviceEnabled)) + { + afDeviceEnabled[index] = enabled; + } #ifdef ZCL_USING_BASIC_CLUSTER_DEVICE_ENABLED_ATTRIBUTE - emberAfWriteServerAttribute(endpoint, - ZCL_BASIC_CLUSTER_ID, - ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, - (uint8_t *)&enabled, - ZCL_BOOLEAN_ATTRIBUTE_TYPE); + emberAfWriteServerAttribute(endpoint, ZCL_BASIC_CLUSTER_ID, ZCL_DEVICE_ENABLED_ATTRIBUTE_ID, (uint8_t *) &enabled, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); #endif } @@ -164,83 +158,86 @@ void emberAfSetDeviceEnabled(uint8_t endpoint, bool enabled) bool emberAfIsDeviceIdentifying(uint8_t endpoint) { #ifdef ZCL_USING_IDENTIFY_CLUSTER_SERVER - uint16_t identifyTime; - EmberAfStatus status = emberAfReadServerAttribute(endpoint, - ZCL_IDENTIFY_CLUSTER_ID, - ZCL_IDENTIFY_TIME_ATTRIBUTE_ID, - (uint8_t *)&identifyTime, - sizeof(identifyTime)); - return (status == EMBER_ZCL_STATUS_SUCCESS && 0 < identifyTime); + uint16_t identifyTime; + EmberAfStatus status = emberAfReadServerAttribute(endpoint, ZCL_IDENTIFY_CLUSTER_ID, ZCL_IDENTIFY_TIME_ATTRIBUTE_ID, + (uint8_t *) &identifyTime, sizeof(identifyTime)); + return (status == EMBER_ZCL_STATUS_SUCCESS && 0 < identifyTime); #else - return false; + return false; #endif } // Calculates difference. See EmberAfDifferenceType for the maximum data size // that this function will support. -EmberAfDifferenceType emberAfGetDifference(uint8_t *pData, - EmberAfDifferenceType value, - uint8_t dataSize) +EmberAfDifferenceType emberAfGetDifference(uint8_t * pData, EmberAfDifferenceType value, uint8_t dataSize) { - EmberAfDifferenceType value2 = 0, diff; - uint8_t i; + EmberAfDifferenceType value2 = 0, diff; + uint8_t i; - // only support data types up to 8 bytes - if (dataSize > sizeof(EmberAfDifferenceType)) { - return 0; - } + // only support data types up to 8 bytes + if (dataSize > sizeof(EmberAfDifferenceType)) + { + return 0; + } - // get the value - for (i = 0; i < dataSize; i++) { - value2 = value2 << 8; + // get the value + for (i = 0; i < dataSize; i++) + { + value2 = value2 << 8; #if (BIGENDIAN_CPU) - value2 += pData[i]; -#else //BIGENDIAN - value2 += pData[dataSize - i - 1]; -#endif //BIGENDIAN - } - - if (value > value2) { - diff = value - value2; - } else { - diff = value2 - value; - } - - return diff; + value2 += pData[i]; +#else // BIGENDIAN + value2 += pData[dataSize - i - 1]; +#endif // BIGENDIAN + } + + if (value > value2) + { + diff = value - value2; + } + else + { + diff = value2 - value; + } + + return diff; } // -------------------------------------------------- -static void prepareForResponse(const EmberAfClusterCommand *cmd) +static void prepareForResponse(const EmberAfClusterCommand * cmd) { - emberAfResponseApsFrame.profileId = cmd->apsFrame->profileId; - emberAfResponseApsFrame.clusterId = cmd->apsFrame->clusterId; - emberAfResponseApsFrame.sourceEndpoint = cmd->apsFrame->destinationEndpoint; - emberAfResponseApsFrame.destinationEndpoint = cmd->apsFrame->sourceEndpoint; - - // Use the default APS options for the response, but also use encryption and - // retries if the incoming message used them. The rationale is that the - // sender of the request cares about some aspects of the delivery, so we as - // the receiver should make equal effort for the response. - emberAfResponseApsFrame.options = EMBER_AF_DEFAULT_APS_OPTIONS; - if ((cmd->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { - emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; - } - if ((cmd->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) { - emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; - } - - if (cmd->interPanHeader == NULL) { - emberAfResponseDestination = cmd->source; - emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; - } else { - emberAfResponseType |= ZCL_UTIL_RESP_INTERPAN; - MEMMOVE(&interpanResponseHeader, - cmd->interPanHeader, - sizeof(EmberAfInterpanHeader)); - // Always send responses as unicast - interpanResponseHeader.messageType = EMBER_AF_INTER_PAN_UNICAST; - } + emberAfResponseApsFrame.profileId = cmd->apsFrame->profileId; + emberAfResponseApsFrame.clusterId = cmd->apsFrame->clusterId; + emberAfResponseApsFrame.sourceEndpoint = cmd->apsFrame->destinationEndpoint; + emberAfResponseApsFrame.destinationEndpoint = cmd->apsFrame->sourceEndpoint; + + // Use the default APS options for the response, but also use encryption and + // retries if the incoming message used them. The rationale is that the + // sender of the request cares about some aspects of the delivery, so we as + // the receiver should make equal effort for the response. + emberAfResponseApsFrame.options = EMBER_AF_DEFAULT_APS_OPTIONS; + if ((cmd->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) + { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } + if ((cmd->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) + { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; + } + + if (cmd->interPanHeader == NULL) + { + emberAfResponseDestination = cmd->source; + emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; + } + else + { + emberAfResponseType |= ZCL_UTIL_RESP_INTERPAN; + MEMMOVE(&interpanResponseHeader, cmd->interPanHeader, sizeof(EmberAfInterpanHeader)); + // Always send responses as unicast + interpanResponseHeader.messageType = EMBER_AF_INTER_PAN_UNICAST; + } } // **************************************** @@ -248,23 +245,24 @@ static void prepareForResponse(const EmberAfClusterCommand *cmd) // **************************************** void emberAfInit(void) { - uint8_t i; + uint8_t i; #ifdef EMBER_AF_ENABLE_STATISTICS - afNumPktsSent = 0; + afNumPktsSent = 0; #endif - for (i = 0; i < EMBER_SUPPORTED_NETWORKS; i++) { - // FIXME: Do we need to support more than one network? - //emberAfPushNetworkIndex(i); - emberAfInitializeAttributes(EMBER_BROADCAST_ENDPOINT); - //emberAfPopNetworkIndex(); - } + for (i = 0; i < EMBER_SUPPORTED_NETWORKS; i++) + { + // FIXME: Do we need to support more than one network? + // emberAfPushNetworkIndex(i); + emberAfInitializeAttributes(EMBER_BROADCAST_ENDPOINT); + // emberAfPopNetworkIndex(); + } - MEMSET(afDeviceEnabled, true, emberAfEndpointCount()); + MEMSET(afDeviceEnabled, true, emberAfEndpointCount()); - // Set up client API buffer. - // FIXME: Is this needed? appResponseData seems unused in the code we pulled - // in so far. + // Set up client API buffer. + // FIXME: Is this needed? appResponseData seems unused in the code we pulled + // in so far. #if 0 emberAfSetExternalBuffer(appResponseData, EMBER_AF_RESPONSE_BUFFER_LEN, @@ -272,23 +270,23 @@ void emberAfInit(void) &emberAfResponseApsFrame); #endif - // initialize event management system - //emAfInitEvents(); + // initialize event management system + // emAfInitEvents(); #ifdef EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS - EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS + EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS #endif - emAfCallInits(); + emAfCallInits(); } void emberAfTick(void) { - // Call the AFV2-specific per-endpoint callbacks - // Anything that defines callbacks as void *TickCallback(void) is called in - // emAfInit(), which is a generated file + // Call the AFV2-specific per-endpoint callbacks + // Anything that defines callbacks as void *TickCallback(void) is called in + // emAfInit(), which is a generated file #ifdef EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_CALLS - EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_CALLS + EMBER_AF_GENERATED_PLUGIN_TICK_FUNCTION_CALLS #endif } @@ -299,24 +297,25 @@ void emberAfTick(void) // **************************************** void emberAfStackDown(void) { - // (Case 14696) Clearing the report table is only necessary if the stack is - // going down for good; if we're rejoining, leave the table intact since we'll - // be right back, hopefully. - // (Issue 77101) Also don't clear the table if the stack has gone down as a - // a result of losing its parent or some other transient state where a future - // rejoin is expected to get us back online. - if (false - // emberStackIsPerformingRejoin() == false - // && emberNetworkState() == EMBER_NO_NETWORK - ) { - // the report table should be cleared when the stack comes down. - // going to a new network means new report devices should be discovered. - // if the table isnt cleared the device keeps trying to send messages. - emberAfClearReportTableCallback(); - } - - emberAfRegistrationAbortCallback(); - emberAfTrustCenterKeepaliveAbortCallback(); + // (Case 14696) Clearing the report table is only necessary if the stack is + // going down for good; if we're rejoining, leave the table intact since we'll + // be right back, hopefully. + // (Issue 77101) Also don't clear the table if the stack has gone down as a + // a result of losing its parent or some other transient state where a future + // rejoin is expected to get us back online. + if (false + // emberStackIsPerformingRejoin() == false + // && emberNetworkState() == EMBER_NO_NETWORK + ) + { + // the report table should be cleared when the stack comes down. + // going to a new network means new report devices should be discovered. + // if the table isnt cleared the device keeps trying to send messages. + emberAfClearReportTableCallback(); + } + + emberAfRegistrationAbortCallback(); + emberAfTrustCenterKeepaliveAbortCallback(); } // **************************************** @@ -325,49 +324,48 @@ void emberAfStackDown(void) uint16_t emberAfFindClusterNameIndexWithMfgCode(uint16_t cluster, uint16_t mfgCode) { - uint16_t index = 0; - while (zclClusterNames[index].id != ZCL_NULL_CLUSTER_ID) { - if (zclClusterNames[index].id == cluster - // This check sees if its a standard cluster, in which mfgCode is ignored - // due to the name being well defined. - // If it is manufacturer specific, then we try to check to see if we - // know the name of the cluster within the list. - // If the mfgCode we are given is null, then we just ignore it for backward - // compatibility reasons - && (cluster < 0xFC00 - || zclClusterNames[index].mfgCode == mfgCode - || mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE)) { - return index; - } - index++; - } - return 0xFFFF; + uint16_t index = 0; + while (zclClusterNames[index].id != ZCL_NULL_CLUSTER_ID) + { + if (zclClusterNames[index].id == cluster + // This check sees if its a standard cluster, in which mfgCode is ignored + // due to the name being well defined. + // If it is manufacturer specific, then we try to check to see if we + // know the name of the cluster within the list. + // If the mfgCode we are given is null, then we just ignore it for backward + // compatibility reasons + && (cluster < 0xFC00 || zclClusterNames[index].mfgCode == mfgCode || mfgCode == EMBER_AF_NULL_MANUFACTURER_CODE)) + { + return index; + } + index++; + } + return 0xFFFF; } uint16_t emberAfFindClusterNameIndex(uint16_t cluster) { - return emberAfFindClusterNameIndexWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); + return emberAfFindClusterNameIndexWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); } // This function parses into the cluster name table, and tries to find // the index in the table that has the two keys: cluster + mfgcode. void emberAfDecodeAndPrintClusterWithMfgCode(uint16_t cluster, uint16_t mfgCode) { - uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); - if (index == 0xFFFF) { - emberAfPrint(emberAfPrintActiveArea, - "(Unknown clus. [0x%2x])", - cluster); - } else { - emberAfPrint(emberAfPrintActiveArea, - "(%p)", - zclClusterNames[index].name); - } + uint16_t index = emberAfFindClusterNameIndexWithMfgCode(cluster, mfgCode); + if (index == 0xFFFF) + { + emberAfPrint(emberAfPrintActiveArea, "(Unknown clus. [0x%2x])", cluster); + } + else + { + emberAfPrint(emberAfPrintActiveArea, "(%p)", zclClusterNames[index].name); + } } void emberAfDecodeAndPrintCluster(uint16_t cluster) { - emberAfDecodeAndPrintClusterWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); + emberAfDecodeAndPrintClusterWithMfgCode(cluster, EMBER_AF_NULL_MANUFACTURER_CODE); } // This function makes the assumption that @@ -379,256 +377,241 @@ void emberAfDecodeAndPrintCluster(uint16_t cluster) // for references to the standard library. uint16_t emberAfGetMfgCodeFromCurrentCommand(void) { - if (emberAfCurrentCommand() != NULL) { - return emberAfCurrentCommand()->mfgCode; - } else { - return EMBER_AF_NULL_MANUFACTURER_CODE; - } + if (emberAfCurrentCommand() != NULL) + { + return emberAfCurrentCommand()->mfgCode; + } + else + { + return EMBER_AF_NULL_MANUFACTURER_CODE; + } } -static void printIncomingZclMessage(const EmberAfClusterCommand *cmd) +static void printIncomingZclMessage(const EmberAfClusterCommand * cmd) { #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP) - if (emberAfPrintReceivedMessages) { - emberAfAppPrint("\r\nT%4x:", emberAfGetCurrentTime()); - emberAfAppPrint("RX len %d, ep %x, clus 0x%2x ", - cmd->bufLen, - cmd->apsFrame->destinationEndpoint, - cmd->apsFrame->clusterId); - emberAfAppDebugExec(emberAfDecodeAndPrintClusterWithMfgCode(cmd->apsFrame->clusterId, cmd->mfgCode)); - if (cmd->mfgSpecific) { - emberAfAppPrint(" mfgId %2x", cmd->mfgCode); - } - emberAfAppPrint(" FC %x seq %x cmd %x payload[", - cmd->buffer[0], // frame control - cmd->seqNum, - cmd->commandId); - emberAfAppFlush(); - emberAfAppPrintBuffer(cmd->buffer + cmd->payloadStartIndex, // message - cmd->bufLen - cmd->payloadStartIndex, // length - true); // spaces? - emberAfAppFlush(); - emberAfAppPrintln("]"); - } + if (emberAfPrintReceivedMessages) + { + emberAfAppPrint("\r\nT%4x:", emberAfGetCurrentTime()); + emberAfAppPrint("RX len %d, ep %x, clus 0x%2x ", cmd->bufLen, cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId); + emberAfAppDebugExec(emberAfDecodeAndPrintClusterWithMfgCode(cmd->apsFrame->clusterId, cmd->mfgCode)); + if (cmd->mfgSpecific) + { + emberAfAppPrint(" mfgId %2x", cmd->mfgCode); + } + emberAfAppPrint(" FC %x seq %x cmd %x payload[", + cmd->buffer[0], // frame control + cmd->seqNum, cmd->commandId); + emberAfAppFlush(); + emberAfAppPrintBuffer(cmd->buffer + cmd->payloadStartIndex, // message + cmd->bufLen - cmd->payloadStartIndex, // length + true); // spaces? + emberAfAppFlush(); + emberAfAppPrintln("]"); + } #endif } -static bool dispatchZclMessage(EmberAfClusterCommand *cmd) +static bool dispatchZclMessage(EmberAfClusterCommand * cmd) { - uint8_t index = emberAfIndexFromEndpoint(cmd->apsFrame->destinationEndpoint); - if (index == 0xFF) { - emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", - cmd->apsFrame->clusterId, - cmd->commandId); - emberAfDebugPrint(" due to invalid endpoint: "); - emberAfDebugPrintln("0x%x", cmd->apsFrame->destinationEndpoint); - return false; - } else if (emberAfNetworkIndexFromEndpointIndex(index) != cmd->networkIndex) { - emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", - cmd->apsFrame->clusterId, - cmd->commandId); - emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", - cmd->apsFrame->destinationEndpoint, - "network"); - emberAfDebugPrintln("%d", cmd->networkIndex); - return false; - } else if (emberAfProfileIdFromIndex(index) != cmd->apsFrame->profileId - && (cmd->apsFrame->profileId != EMBER_WILDCARD_PROFILE_ID - || (EMBER_MAXIMUM_STANDARD_PROFILE_ID - < emberAfProfileIdFromIndex(index)))) { - emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", - cmd->apsFrame->clusterId, - cmd->commandId); - emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", - cmd->apsFrame->destinationEndpoint, - "profile"); - emberAfDebugPrintln("0x%2x", cmd->apsFrame->profileId); - return false; - } else if ((cmd->type == EMBER_INCOMING_MULTICAST - || cmd->type == EMBER_INCOMING_MULTICAST_LOOPBACK) - && !emberAfGroupsClusterEndpointInGroupCallback(cmd->apsFrame->destinationEndpoint, - cmd->apsFrame->groupId)) { - emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", - cmd->apsFrame->clusterId, - cmd->commandId); - emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", - cmd->apsFrame->destinationEndpoint, - "group"); - emberAfDebugPrintln("0x%2x", cmd->apsFrame->groupId); - return false; - } else { - return (cmd->clusterSpecific - ? emAfProcessClusterSpecificCommand(cmd) - : emAfProcessGlobalCommand(cmd)); - } + uint8_t index = emberAfIndexFromEndpoint(cmd->apsFrame->destinationEndpoint); + if (index == 0xFF) + { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", cmd->apsFrame->clusterId, cmd->commandId); + emberAfDebugPrint(" due to invalid endpoint: "); + emberAfDebugPrintln("0x%x", cmd->apsFrame->destinationEndpoint); + return false; + } + else if (emberAfNetworkIndexFromEndpointIndex(index) != cmd->networkIndex) + { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", cmd->apsFrame->clusterId, cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", cmd->apsFrame->destinationEndpoint, "network"); + emberAfDebugPrintln("%d", cmd->networkIndex); + return false; + } + else if (emberAfProfileIdFromIndex(index) != cmd->apsFrame->profileId && + (cmd->apsFrame->profileId != EMBER_WILDCARD_PROFILE_ID || + (EMBER_MAXIMUM_STANDARD_PROFILE_ID < emberAfProfileIdFromIndex(index)))) + { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", cmd->apsFrame->clusterId, cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", cmd->apsFrame->destinationEndpoint, "profile"); + emberAfDebugPrintln("0x%2x", cmd->apsFrame->profileId); + return false; + } + else if ((cmd->type == EMBER_INCOMING_MULTICAST || cmd->type == EMBER_INCOMING_MULTICAST_LOOPBACK) && + !emberAfGroupsClusterEndpointInGroupCallback(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->groupId)) + { + emberAfDebugPrint("Drop cluster 0x%2x command 0x%x", cmd->apsFrame->clusterId, cmd->commandId); + emberAfDebugPrint(" for endpoint 0x%x due to wrong %p: ", cmd->apsFrame->destinationEndpoint, "group"); + emberAfDebugPrintln("0x%2x", cmd->apsFrame->groupId); + return false; + } + else + { + return (cmd->clusterSpecific ? emAfProcessClusterSpecificCommand(cmd) : emAfProcessGlobalCommand(cmd)); + } } -bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, - EmberIncomingMessageType type, - uint8_t* message, - uint16_t messageLength, - EmberNodeId source, - InterPanHeader* interPanHeader, - EmberAfClusterCommand* returnCmd) +bool emberAfProcessMessageIntoZclCmd(EmberApsFrame * apsFrame, EmberIncomingMessageType type, uint8_t * message, + uint16_t messageLength, EmberNodeId source, InterPanHeader * interPanHeader, + EmberAfClusterCommand * returnCmd) { - uint8_t minLength = (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK - ? EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD - : EMBER_AF_ZCL_OVERHEAD); + uint8_t minLength = + (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK ? EMBER_AF_ZCL_MANUFACTURER_SPECIFIC_OVERHEAD : EMBER_AF_ZCL_OVERHEAD); - if (messageLength < minLength) { - emberAfAppPrintln("%pRX pkt too short: %d < %d", "ERROR: ", messageLength, minLength); - return false; - } - - // Populate the cluster command struct for processing. - returnCmd->apsFrame = apsFrame; - returnCmd->type = type; - returnCmd->source = source; - returnCmd->buffer = message; - returnCmd->bufLen = messageLength; - returnCmd->clusterSpecific = (message[0] & ZCL_CLUSTER_SPECIFIC_COMMAND); - returnCmd->mfgSpecific = (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK); - returnCmd->direction = ((message[0] & ZCL_FRAME_CONTROL_DIRECTION_MASK) - ? ZCL_DIRECTION_SERVER_TO_CLIENT - : ZCL_DIRECTION_CLIENT_TO_SERVER); - returnCmd->payloadStartIndex = 1; - if (returnCmd->mfgSpecific) { - returnCmd->mfgCode = emberAfGetInt16u(message, returnCmd->payloadStartIndex, messageLength); - returnCmd->payloadStartIndex += 2; - } else { - returnCmd->mfgCode = EMBER_AF_NULL_MANUFACTURER_CODE; - } - returnCmd->seqNum = message[returnCmd->payloadStartIndex++]; - returnCmd->commandId = message[returnCmd->payloadStartIndex++]; - if ( returnCmd->payloadStartIndex > returnCmd->bufLen ) { - emberAfAppPrintln("%pRX pkt malformed: %d < %d", "ERROR: ", returnCmd->bufLen, returnCmd->payloadStartIndex); - return false; - } - returnCmd->interPanHeader = interPanHeader; - // returnCmd->networkIndex = emberGetCurrentNetwork(); - return true; + if (messageLength < minLength) + { + emberAfAppPrintln("%pRX pkt too short: %d < %d", "ERROR: ", messageLength, minLength); + return false; + } + + // Populate the cluster command struct for processing. + returnCmd->apsFrame = apsFrame; + returnCmd->type = type; + returnCmd->source = source; + returnCmd->buffer = message; + returnCmd->bufLen = messageLength; + returnCmd->clusterSpecific = (message[0] & ZCL_CLUSTER_SPECIFIC_COMMAND); + returnCmd->mfgSpecific = (message[0] & ZCL_MANUFACTURER_SPECIFIC_MASK); + returnCmd->direction = + ((message[0] & ZCL_FRAME_CONTROL_DIRECTION_MASK) ? ZCL_DIRECTION_SERVER_TO_CLIENT : ZCL_DIRECTION_CLIENT_TO_SERVER); + returnCmd->payloadStartIndex = 1; + if (returnCmd->mfgSpecific) + { + returnCmd->mfgCode = emberAfGetInt16u(message, returnCmd->payloadStartIndex, messageLength); + returnCmd->payloadStartIndex += 2; + } + else + { + returnCmd->mfgCode = EMBER_AF_NULL_MANUFACTURER_CODE; + } + returnCmd->seqNum = message[returnCmd->payloadStartIndex++]; + returnCmd->commandId = message[returnCmd->payloadStartIndex++]; + if (returnCmd->payloadStartIndex > returnCmd->bufLen) + { + emberAfAppPrintln("%pRX pkt malformed: %d < %d", "ERROR: ", returnCmd->bufLen, returnCmd->payloadStartIndex); + return false; + } + returnCmd->interPanHeader = interPanHeader; + // returnCmd->networkIndex = emberGetCurrentNetwork(); + return true; } // a single call to process global and cluster-specific messages and callbacks. -bool emberAfProcessMessage(EmberApsFrame *apsFrame, - EmberIncomingMessageType type, - uint8_t *message, - uint16_t msgLen, - EmberNodeId source, - InterPanHeader *interPanHeader) +bool emberAfProcessMessage(EmberApsFrame * apsFrame, EmberIncomingMessageType type, uint8_t * message, uint16_t msgLen, + EmberNodeId source, InterPanHeader * interPanHeader) { - EmberStatus sendStatus; - bool msgHandled = false; - //reset/reinitialize curCmd - curCmd = staticCmd; - if (!emberAfProcessMessageIntoZclCmd(apsFrame, - type, - message, - msgLen, - source, - interPanHeader, - &curCmd)) { - goto kickout; - } - - emAfCurrentCommand = &curCmd; - - // All of these should be covered by the EmberAfClusterCommand but are - // still here until all the code is moved over to use the cmd. -WEH - emberAfIncomingZclSequenceNumber = curCmd.seqNum; - - printIncomingZclMessage(&curCmd); - prepareForResponse(&curCmd); - - if (emAfPreCommandReceived(&curCmd)) { - msgHandled = true; - goto kickout; - } - - if (interPanHeader == NULL) { - bool broadcast = (type == EMBER_INCOMING_BROADCAST - || type == EMBER_INCOMING_BROADCAST_LOOPBACK - || type == EMBER_INCOMING_MULTICAST - || type == EMBER_INCOMING_MULTICAST_LOOPBACK); - - // if the cluster for the incoming message requires security and - // doesnt have it return default response STATUS_FAILURE - if (emberAfDetermineIfLinkSecurityIsRequired(curCmd.commandId, - true, // incoming - broadcast, - curCmd.apsFrame->profileId, - curCmd.apsFrame->clusterId, - curCmd.source) - && (!(curCmd.apsFrame->options & EMBER_APS_OPTION_ENCRYPTION))) { - emberAfDebugPrintln("Drop clus %2x due to no aps security", - curCmd.apsFrame->clusterId); - afNoSecurityForDefaultResponse = true; - sendStatus = emberAfSendDefaultResponse(&curCmd, EMBER_ZCL_STATUS_NOT_AUTHORIZED); - if (EMBER_SUCCESS != sendStatus) { - emberAfDebugPrintln("Util: failed to send %s response: 0x%x", - "default", - sendStatus); - } - afNoSecurityForDefaultResponse = false; - - // Mark the message as processed. It failed security processing, so no - // other parts of the code should act upon it. - msgHandled = true; - goto kickout; - } - } else if (!(interPanHeader->options - & EMBER_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS)) { - // For safety, dump all interpan messages that don't have a long - // source in the MAC layer. In theory they should not get past - // the MAC filters but this is insures they will not get processed. - goto kickout; - } else { - // MISRA requires ..else if.. to have terminating else. - } - - if (curCmd.apsFrame->destinationEndpoint == EMBER_BROADCAST_ENDPOINT) { - uint8_t i; - for (i = 0; i < emberAfEndpointCount(); i++) { - uint8_t endpoint = emberAfEndpointFromIndex(i); - if (!emberAfEndpointIndexIsEnabled(i) - || !emberAfContainsClusterWithMfgCode(endpoint, curCmd.apsFrame->clusterId, curCmd.mfgCode)) { - continue; - } - // Since the APS frame is cleared after each sending, - // we must reinitialize it. It is cleared to prevent - // data from leaking out and being sent inadvertently. - prepareForResponse(&curCmd); - - // Change the destination endpoint of the incoming command and the source - // source endpoint of the response so they both reflect the endpoint the - // message is actually being passed to in this iteration of the loop. - curCmd.apsFrame->destinationEndpoint = endpoint; - emberAfResponseApsFrame.sourceEndpoint = endpoint; - if (dispatchZclMessage(&curCmd)) { + EmberStatus sendStatus; + bool msgHandled = false; + // reset/reinitialize curCmd + curCmd = staticCmd; + if (!emberAfProcessMessageIntoZclCmd(apsFrame, type, message, msgLen, source, interPanHeader, &curCmd)) + { + goto kickout; + } + + emAfCurrentCommand = &curCmd; + + // All of these should be covered by the EmberAfClusterCommand but are + // still here until all the code is moved over to use the cmd. -WEH + emberAfIncomingZclSequenceNumber = curCmd.seqNum; + + printIncomingZclMessage(&curCmd); + prepareForResponse(&curCmd); + + if (emAfPreCommandReceived(&curCmd)) + { msgHandled = true; - } - } - } else { - msgHandled = dispatchZclMessage(&curCmd); - } - - kickout: - emberAfClearResponseData(); - MEMSET(&interpanResponseHeader, - 0, - sizeof(EmberAfInterpanHeader)); - emAfCurrentCommand = NULL; - return msgHandled; + goto kickout; + } + + if (interPanHeader == NULL) + { + bool broadcast = (type == EMBER_INCOMING_BROADCAST || type == EMBER_INCOMING_BROADCAST_LOOPBACK || + type == EMBER_INCOMING_MULTICAST || type == EMBER_INCOMING_MULTICAST_LOOPBACK); + + // if the cluster for the incoming message requires security and + // doesnt have it return default response STATUS_FAILURE + if (emberAfDetermineIfLinkSecurityIsRequired(curCmd.commandId, + true, // incoming + broadcast, curCmd.apsFrame->profileId, curCmd.apsFrame->clusterId, + curCmd.source) && + (!(curCmd.apsFrame->options & EMBER_APS_OPTION_ENCRYPTION))) + { + emberAfDebugPrintln("Drop clus %2x due to no aps security", curCmd.apsFrame->clusterId); + afNoSecurityForDefaultResponse = true; + sendStatus = emberAfSendDefaultResponse(&curCmd, EMBER_ZCL_STATUS_NOT_AUTHORIZED); + if (EMBER_SUCCESS != sendStatus) + { + emberAfDebugPrintln("Util: failed to send %s response: 0x%x", "default", sendStatus); + } + afNoSecurityForDefaultResponse = false; + + // Mark the message as processed. It failed security processing, so no + // other parts of the code should act upon it. + msgHandled = true; + goto kickout; + } + } + else if (!(interPanHeader->options & EMBER_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS)) + { + // For safety, dump all interpan messages that don't have a long + // source in the MAC layer. In theory they should not get past + // the MAC filters but this is insures they will not get processed. + goto kickout; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } + + if (curCmd.apsFrame->destinationEndpoint == EMBER_BROADCAST_ENDPOINT) + { + uint8_t i; + for (i = 0; i < emberAfEndpointCount(); i++) + { + uint8_t endpoint = emberAfEndpointFromIndex(i); + if (!emberAfEndpointIndexIsEnabled(i) || + !emberAfContainsClusterWithMfgCode(endpoint, curCmd.apsFrame->clusterId, curCmd.mfgCode)) + { + continue; + } + // Since the APS frame is cleared after each sending, + // we must reinitialize it. It is cleared to prevent + // data from leaking out and being sent inadvertently. + prepareForResponse(&curCmd); + + // Change the destination endpoint of the incoming command and the source + // source endpoint of the response so they both reflect the endpoint the + // message is actually being passed to in this iteration of the loop. + curCmd.apsFrame->destinationEndpoint = endpoint; + emberAfResponseApsFrame.sourceEndpoint = endpoint; + if (dispatchZclMessage(&curCmd)) + { + msgHandled = true; + } + } + } + else + { + msgHandled = dispatchZclMessage(&curCmd); + } + +kickout: + emberAfClearResponseData(); + MEMSET(&interpanResponseHeader, 0, sizeof(EmberAfInterpanHeader)); + emAfCurrentCommand = NULL; + return msgHandled; } uint8_t emberAfNextSequence(void) { - return ((++emberAfSequenceNumber) & EMBER_AF_ZCL_SEQUENCE_MASK); + return ((++emberAfSequenceNumber) & EMBER_AF_ZCL_SEQUENCE_MASK); } uint8_t emberAfGetLastSequenceNumber(void) { - return (emberAfSequenceNumber & EMBER_AF_ZCL_SEQUENCE_MASK); + return (emberAfSequenceNumber & EMBER_AF_ZCL_SEQUENCE_MASK); } // the caller to the library can set a flag to say do not respond to the @@ -638,105 +621,131 @@ uint8_t emberAfGetLastSequenceNumber(void) // message that gets parsed). void emberAfSetNoReplyForNextMessage(bool set) { - if (set) { - emberAfResponseType |= ZCL_UTIL_RESP_NONE; - } else { - emberAfResponseType &= ~ZCL_UTIL_RESP_NONE; - } + if (set) + { + emberAfResponseType |= ZCL_UTIL_RESP_NONE; + } + else + { + emberAfResponseType &= ~ZCL_UTIL_RESP_NONE; + } } void emberAfSetRetryOverride(EmberAfRetryOverride value) { - emberAfApsRetryOverride = value; + emberAfApsRetryOverride = value; } EmberAfRetryOverride emberAfGetRetryOverride(void) { - return (EmberAfRetryOverride) emberAfApsRetryOverride; + return (EmberAfRetryOverride) emberAfApsRetryOverride; } -void emAfApplyRetryOverride(EmberApsOption *options) +void emAfApplyRetryOverride(EmberApsOption * options) { - if (options == NULL) { - return; - } else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_SET) { - *options |= EMBER_APS_OPTION_RETRY; - } else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_UNSET) { - *options &= ~EMBER_APS_OPTION_RETRY; - } else { - // MISRA requires ..else if.. to have terminating else. - } + if (options == NULL) + { + return; + } + else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_SET) + { + *options |= EMBER_APS_OPTION_RETRY; + } + else if (emberAfApsRetryOverride == EMBER_AF_RETRY_OVERRIDE_UNSET) + { + *options &= ~EMBER_APS_OPTION_RETRY; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } } void emberAfSetDisableDefaultResponse(EmberAfDisableDefaultResponse value) { - emAfDisableDefaultResponse = value; - if (value != EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) { - emAfSavedDisableDefaultResponseVale = value; - } + emAfDisableDefaultResponse = value; + if (value != EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) + { + emAfSavedDisableDefaultResponseVale = value; + } } EmberAfDisableDefaultResponse emberAfGetDisableDefaultResponse(void) { - return (EmberAfDisableDefaultResponse) emAfDisableDefaultResponse; + return (EmberAfDisableDefaultResponse) emAfDisableDefaultResponse; } -void emAfApplyDisableDefaultResponse(uint8_t *frame_control) +void emAfApplyDisableDefaultResponse(uint8_t * frame_control) { - if (frame_control == NULL) { - return; - } else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) { - emAfDisableDefaultResponse = emAfSavedDisableDefaultResponseVale; - *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; - } else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT) { - *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; - } else { - // MISRA requires ..else if.. to have terminating else. - } + if (frame_control == NULL) + { + return; + } + else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT) + { + emAfDisableDefaultResponse = emAfSavedDisableDefaultResponseVale; + *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; + } + else if (emAfDisableDefaultResponse == EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT) + { + *frame_control |= ZCL_DISABLE_DEFAULT_RESPONSE_MASK; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } } EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) { - EmberStatus status; - uint8_t label; + EmberStatus status; + uint8_t label; + + // If the no-response flag is set, don't send anything. + if ((emberAfResponseType & ZCL_UTIL_RESP_NONE) != 0U) + { + emberAfDebugPrintln("ZCL Util: no response at user request"); + return EMBER_SUCCESS; + } - // If the no-response flag is set, don't send anything. - if ((emberAfResponseType & ZCL_UTIL_RESP_NONE) != 0U) { - emberAfDebugPrintln("ZCL Util: no response at user request"); - return EMBER_SUCCESS; - } - - // Make sure we are respecting the request APS options - // there are seemingly some calls to emberAfSendResponse - // that occur outside of the emberAfProcessMessage context, - // which leads to a bad memory reference - AHilton - if (emberAfCurrentCommand() != NULL) { - if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { - emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; - } - if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) { - emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; - } - } - - // Fill commands may increase the sequence. For responses, we want to make - // sure the sequence is reset to that of the request. - if ((appResponseData[0] & ZCL_MANUFACTURER_SPECIFIC_MASK) != 0U) { - appResponseData[3] = emberAfIncomingZclSequenceNumber; - } else { - appResponseData[1] = emberAfIncomingZclSequenceNumber; - } - - // The manner in which the message is sent depends on the response flags and - // the destination of the message. - if ((emberAfResponseType & ZCL_UTIL_RESP_INTERPAN) != 0U) { - label = 'I'; - status = emberAfInterpanSendMessageCallback(&interpanResponseHeader, - appResponseLength, - appResponseData); - emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; - } else if (emberAfResponseDestination < EMBER_BROADCAST_ADDRESS) { - label = 'U'; + // Make sure we are respecting the request APS options + // there are seemingly some calls to emberAfSendResponse + // that occur outside of the emberAfProcessMessage context, + // which leads to a bad memory reference - AHilton + if (emberAfCurrentCommand() != NULL) + { + if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) + { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_ENCRYPTION; + } + if ((emberAfCurrentCommand()->apsFrame->options & EMBER_APS_OPTION_RETRY) != 0U) + { + emberAfResponseApsFrame.options |= EMBER_APS_OPTION_RETRY; + } + } + + // Fill commands may increase the sequence. For responses, we want to make + // sure the sequence is reset to that of the request. + if ((appResponseData[0] & ZCL_MANUFACTURER_SPECIFIC_MASK) != 0U) + { + appResponseData[3] = emberAfIncomingZclSequenceNumber; + } + else + { + appResponseData[1] = emberAfIncomingZclSequenceNumber; + } + + // The manner in which the message is sent depends on the response flags and + // the destination of the message. + if ((emberAfResponseType & ZCL_UTIL_RESP_INTERPAN) != 0U) + { + label = 'I'; + status = emberAfInterpanSendMessageCallback(&interpanResponseHeader, appResponseLength, appResponseData); + emberAfResponseType &= ~ZCL_UTIL_RESP_INTERPAN; + } + else if (emberAfResponseDestination < EMBER_BROADCAST_ADDRESS) + { + label = 'U'; #if 0 status = emberAfSendUnicastWithCallback(EMBER_OUTGOING_DIRECT, emberAfResponseDestination, @@ -745,10 +754,12 @@ EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) appResponseData, callback); #else - status = EMBER_SUCCESS; + status = EMBER_SUCCESS; #endif - } else { - label = 'B'; + } + else + { + label = 'B'; #if 0 status = emberAfSendBroadcastWithCallback(emberAfResponseDestination, &emberAfResponseApsFrame, @@ -756,375 +767,400 @@ EmberStatus emberAfSendResponseWithCallback(EmberAfMessageSentFunction callback) appResponseData, callback); #else - status = EMBER_SUCCESS; + status = EMBER_SUCCESS; #endif - } - UNUSED_VAR(label); - emberAfDebugPrintln("T%4x:TX (%p) %ccast 0x%x%p", - emberAfGetCurrentTime(), - "resp", - label, - status, - ((emberAfResponseApsFrame.options - & EMBER_APS_OPTION_ENCRYPTION) - ? " w/ link key" : "")); - emberAfDebugPrint("TX buffer: ["); - emberAfDebugFlush(); - emberAfDebugPrintBuffer(appResponseData, appResponseLength, true); - emberAfDebugPrintln("]"); - emberAfDebugFlush(); + } + UNUSED_VAR(label); + emberAfDebugPrintln("T%4x:TX (%p) %ccast 0x%x%p", emberAfGetCurrentTime(), "resp", label, status, + ((emberAfResponseApsFrame.options & EMBER_APS_OPTION_ENCRYPTION) ? " w/ link key" : "")); + emberAfDebugPrint("TX buffer: ["); + emberAfDebugFlush(); + emberAfDebugPrintBuffer(appResponseData, appResponseLength, true); + emberAfDebugPrintln("]"); + emberAfDebugFlush(); #ifdef EMBER_AF_ENABLE_STATISTICS - if (status == EMBER_SUCCESS) { - afNumPktsSent++; - } + if (status == EMBER_SUCCESS) + { + afNumPktsSent++; + } #endif - return status; + return status; } EmberStatus emberAfSendResponse(void) { - return emberAfSendResponseWithCallback(NULL); + return emberAfSendResponseWithCallback(NULL); } -EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, - EmberAfMessageSentFunction callback) +EmberStatus emberAfSendImmediateDefaultResponseWithCallback(EmberAfStatus status, EmberAfMessageSentFunction callback) { - return emberAfSendDefaultResponseWithCallback(emberAfCurrentCommand(), status, callback); + return emberAfSendDefaultResponseWithCallback(emberAfCurrentCommand(), status, callback); } EmberStatus emberAfSendImmediateDefaultResponse(EmberAfStatus status) { - return emberAfSendImmediateDefaultResponseWithCallback(status, NULL); + return emberAfSendImmediateDefaultResponseWithCallback(status, NULL); } -EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand *cmd, - EmberAfStatus status, +EmberStatus emberAfSendDefaultResponseWithCallback(const EmberAfClusterCommand * cmd, EmberAfStatus status, EmberAfMessageSentFunction callback) { - uint8_t frameControl; + uint8_t frameControl; - // Default Response commands are only sent in response to unicast commands. - if (cmd->type != EMBER_INCOMING_UNICAST - && cmd->type != EMBER_INCOMING_UNICAST_REPLY) { - return EMBER_SUCCESS; - } + // Default Response commands are only sent in response to unicast commands. + if (cmd->type != EMBER_INCOMING_UNICAST && cmd->type != EMBER_INCOMING_UNICAST_REPLY) + { + return EMBER_SUCCESS; + } - // If the Disable Default Response sub-field is set, Default Response commands - // are only sent if there was an error. - if ((cmd->buffer[0] & ZCL_DISABLE_DEFAULT_RESPONSE_MASK) - && status == EMBER_ZCL_STATUS_SUCCESS) { - return EMBER_SUCCESS; - } + // If the Disable Default Response sub-field is set, Default Response commands + // are only sent if there was an error. + if ((cmd->buffer[0] & ZCL_DISABLE_DEFAULT_RESPONSE_MASK) && status == EMBER_ZCL_STATUS_SUCCESS) + { + return EMBER_SUCCESS; + } - // Default Response commands are never sent in response to other Default - // Response commands. - if (!cmd->clusterSpecific - && cmd->commandId == ZCL_DEFAULT_RESPONSE_COMMAND_ID) { - return EMBER_SUCCESS; - } - - appResponseLength = 0; - frameControl = (ZCL_GLOBAL_COMMAND - | (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER - ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT - : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER)); - - if (!cmd->mfgSpecific) { - emberAfPutInt8uInResp(frameControl & (uint8_t) ~ZCL_MANUFACTURER_SPECIFIC_MASK); - } else { - emberAfPutInt8uInResp(frameControl | ZCL_MANUFACTURER_SPECIFIC_MASK); - emberAfPutInt16uInResp(cmd->mfgCode); - } - emberAfPutInt8uInResp(cmd->seqNum); - emberAfPutInt8uInResp(ZCL_DEFAULT_RESPONSE_COMMAND_ID); - emberAfPutInt8uInResp(cmd->commandId); - emberAfPutInt8uInResp(status); - - prepareForResponse(cmd); - return emberAfSendResponseWithCallback(callback); + // Default Response commands are never sent in response to other Default + // Response commands. + if (!cmd->clusterSpecific && cmd->commandId == ZCL_DEFAULT_RESPONSE_COMMAND_ID) + { + return EMBER_SUCCESS; + } + + appResponseLength = 0; + frameControl = (ZCL_GLOBAL_COMMAND | + (cmd->direction == ZCL_DIRECTION_CLIENT_TO_SERVER ? ZCL_FRAME_CONTROL_SERVER_TO_CLIENT + : ZCL_FRAME_CONTROL_CLIENT_TO_SERVER)); + + if (!cmd->mfgSpecific) + { + emberAfPutInt8uInResp(frameControl & (uint8_t) ~ZCL_MANUFACTURER_SPECIFIC_MASK); + } + else + { + emberAfPutInt8uInResp(frameControl | ZCL_MANUFACTURER_SPECIFIC_MASK); + emberAfPutInt16uInResp(cmd->mfgCode); + } + emberAfPutInt8uInResp(cmd->seqNum); + emberAfPutInt8uInResp(ZCL_DEFAULT_RESPONSE_COMMAND_ID); + emberAfPutInt8uInResp(cmd->commandId); + emberAfPutInt8uInResp(status); + + prepareForResponse(cmd); + return emberAfSendResponseWithCallback(callback); } -EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand *cmd, - EmberAfStatus status) +EmberStatus emberAfSendDefaultResponse(const EmberAfClusterCommand * cmd, EmberAfStatus status) { - return emberAfSendDefaultResponseWithCallback(cmd, status, NULL); + return emberAfSendDefaultResponseWithCallback(cmd, status, NULL); } -bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, - bool incoming, - bool broadcast, - EmberAfProfileId profileId, - EmberAfClusterId clusterId, - EmberNodeId remoteNodeId) +bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, bool incoming, bool broadcast, EmberAfProfileId profileId, + EmberAfClusterId clusterId, EmberNodeId remoteNodeId) { - (void)afNoSecurityForDefaultResponse; // remove warning if not used - - // If we have turned off all APS security (needed for testing), then just - // always return false. - if ((emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) || afNoSecurityForDefaultResponse) { - afNoSecurityForDefaultResponse = false; - return false; - } + (void) afNoSecurityForDefaultResponse; // remove warning if not used + + // If we have turned off all APS security (needed for testing), then just + // always return false. + if ((emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) || afNoSecurityForDefaultResponse) + { + afNoSecurityForDefaultResponse = false; + return false; + } - // NOTE: In general if it is a unicast, and one of the SE clusters, it - // requires APS encryption. A few special cases exists that we allow for - // but those must be explicitly spelled out here. + // NOTE: In general if it is a unicast, and one of the SE clusters, it + // requires APS encryption. A few special cases exists that we allow for + // but those must be explicitly spelled out here. - // Assume that if the local device is broadcasting, even if it is using one - // of the SE clusters, this is okay. - if (!incoming && broadcast) { - return false; - } + // Assume that if the local device is broadcasting, even if it is using one + // of the SE clusters, this is okay. + if (!incoming && broadcast) + { + return false; + } - // At this point if the CLI command has been issued, it's safe to over any other settings - // and return. - // This change allows HA applications to use the CLI option to enable APS security. - if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_ENABLED) { - return true; - } else if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) { - //The default return value before this change. - return false; - } else { - // MISRA requires ..else if.. to have terminating else. - } + // At this point if the CLI command has been issued, it's safe to over any other settings + // and return. + // This change allows HA applications to use the CLI option to enable APS security. + if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_ENABLED) + { + return true; + } + else if (emAfTestApsSecurityOverride == APS_TEST_SECURITY_DISABLED) + { + // The default return value before this change. + return false; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } #ifdef EMBER_AF_HAS_SECURITY_PROFILE_SE - if (emberAfIsCurrentSecurityProfileSmartEnergy()) { - // Check against profile IDs that use APS security on these clusters. - if (profileId != SE_PROFILE_ID && profileId != EMBER_WILDCARD_PROFILE_ID) { - return false; - } - - // Loopback packets do not require security - if (emberGetNodeId() == remoteNodeId) { - return false; - } - - // This list comes from Section 5.4.6 of the SE spec. - switch (clusterId) { - case ZCL_TIME_CLUSTER_ID: - case ZCL_COMMISSIONING_CLUSTER_ID: - case ZCL_PRICE_CLUSTER_ID: - case ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID: - case ZCL_SIMPLE_METERING_CLUSTER_ID: - case ZCL_MESSAGING_CLUSTER_ID: - case ZCL_TUNNELING_CLUSTER_ID: - case ZCL_GENERIC_TUNNEL_CLUSTER_ID: - case ZCL_PREPAYMENT_CLUSTER_ID: - case ZCL_CALENDAR_CLUSTER_ID: - case ZCL_DEVICE_MANAGEMENT_CLUSTER_ID: - case ZCL_EVENTS_CLUSTER_ID: - case ZCL_MDU_PAIRING_CLUSTER_ID: - case ZCL_ENERGY_MANAGEMENT_CLUSTER_ID: - case ZCL_SUB_GHZ_CLUSTER_ID: - return true; - case ZCL_OTA_BOOTLOAD_CLUSTER_ID: - if (commandId == ZCL_IMAGE_NOTIFY_COMMAND_ID && broadcast) { - return false; - } else { - return true; + if (emberAfIsCurrentSecurityProfileSmartEnergy()) + { + // Check against profile IDs that use APS security on these clusters. + if (profileId != SE_PROFILE_ID && profileId != EMBER_WILDCARD_PROFILE_ID) + { + return false; + } + + // Loopback packets do not require security + if (emberGetNodeId() == remoteNodeId) + { + return false; + } + + // This list comes from Section 5.4.6 of the SE spec. + switch (clusterId) + { + case ZCL_TIME_CLUSTER_ID: + case ZCL_COMMISSIONING_CLUSTER_ID: + case ZCL_PRICE_CLUSTER_ID: + case ZCL_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_ID: + case ZCL_SIMPLE_METERING_CLUSTER_ID: + case ZCL_MESSAGING_CLUSTER_ID: + case ZCL_TUNNELING_CLUSTER_ID: + case ZCL_GENERIC_TUNNEL_CLUSTER_ID: + case ZCL_PREPAYMENT_CLUSTER_ID: + case ZCL_CALENDAR_CLUSTER_ID: + case ZCL_DEVICE_MANAGEMENT_CLUSTER_ID: + case ZCL_EVENTS_CLUSTER_ID: + case ZCL_MDU_PAIRING_CLUSTER_ID: + case ZCL_ENERGY_MANAGEMENT_CLUSTER_ID: + case ZCL_SUB_GHZ_CLUSTER_ID: + return true; + case ZCL_OTA_BOOTLOAD_CLUSTER_ID: + if (commandId == ZCL_IMAGE_NOTIFY_COMMAND_ID && broadcast) + { + return false; + } + else + { + return true; + } + default: + break; } - default: - break; } - } -#endif //EMBER_AF_HAS_SECURITY_PROFILE_SE +#endif // EMBER_AF_HAS_SECURITY_PROFILE_SE - // All works with all hubs commands require aps link key authorization - if (clusterId == ZCL_SL_WWAH_CLUSTER_ID) { - return true; - } + // All works with all hubs commands require aps link key authorization + if (clusterId == ZCL_SL_WWAH_CLUSTER_ID) + { + return true; + } - if (emberAfClusterSecurityCustomCallback(profileId, - clusterId, - incoming, - commandId)) { - return true; - } + if (emberAfClusterSecurityCustomCallback(profileId, clusterId, incoming, commandId)) + { + return true; + } -//APS_TEST_SECURITY_DEFAULT at this point returns false. - return false; + // APS_TEST_SECURITY_DEFAULT at this point returns false. + return false; } -uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, - uint16_t indexOrDestination, - EmberApsFrame *apsFrame) +uint8_t emberAfMaximumApsPayloadLength(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame) { - EmberNodeId destination = EMBER_UNKNOWN_NODE_ID; - uint8_t max = EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH; - - if ((apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) { - max -= EMBER_AF_APS_ENCRYPTION_OVERHEAD; - } - if ((apsFrame->options & EMBER_APS_OPTION_SOURCE_EUI64) != 0U) { - max -= EUI64_SIZE; - } - if ((apsFrame->options & EMBER_APS_OPTION_DESTINATION_EUI64) != 0U) { - max -= EUI64_SIZE; - } - if ((apsFrame->options & EMBER_APS_OPTION_FRAGMENT) != 0U) { - max -= EMBER_AF_APS_FRAGMENTATION_OVERHEAD; - } - - switch (type) { + EmberNodeId destination = EMBER_UNKNOWN_NODE_ID; + uint8_t max = EMBER_AF_MAXIMUM_APS_PAYLOAD_LENGTH; + + if ((apsFrame->options & EMBER_APS_OPTION_ENCRYPTION) != 0U) + { + max -= EMBER_AF_APS_ENCRYPTION_OVERHEAD; + } + if ((apsFrame->options & EMBER_APS_OPTION_SOURCE_EUI64) != 0U) + { + max -= EUI64_SIZE; + } + if ((apsFrame->options & EMBER_APS_OPTION_DESTINATION_EUI64) != 0U) + { + max -= EUI64_SIZE; + } + if ((apsFrame->options & EMBER_APS_OPTION_FRAGMENT) != 0U) + { + max -= EMBER_AF_APS_FRAGMENTATION_OVERHEAD; + } + + switch (type) + { case EMBER_OUTGOING_DIRECT: - destination = indexOrDestination; - break; + destination = indexOrDestination; + break; case EMBER_OUTGOING_VIA_ADDRESS_TABLE: - // destination = emberGetAddressTableRemoteNodeId(indexOrDestination); - break; + // destination = emberGetAddressTableRemoteNodeId(indexOrDestination); + break; case EMBER_OUTGOING_VIA_BINDING: - // destination = emberGetBindingRemoteNodeId(indexOrDestination); - break; + // destination = emberGetBindingRemoteNodeId(indexOrDestination); + break; case EMBER_OUTGOING_MULTICAST: - // APS multicast messages include the two-byte group id and exclude the - // one-byte destination endpoint, for a net loss of an extra byte. - max--; - break; + // APS multicast messages include the two-byte group id and exclude the + // one-byte destination endpoint, for a net loss of an extra byte. + max--; + break; case EMBER_OUTGOING_BROADCAST: - break; + break; default: - // MISRA requires default case. - break; - } + // MISRA requires default case. + break; + } - max -= emberAfGetSourceRouteOverheadCallback(destination); + max -= emberAfGetSourceRouteOverheadCallback(destination); - return max; + return max; } -void emberAfCopyInt16u(uint8_t *data, uint16_t index, uint16_t x) +void emberAfCopyInt16u(uint8_t * data, uint16_t index, uint16_t x) { - data[index] = (uint8_t) ( ((x) ) & 0xFF); - data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); + data[index] = (uint8_t)(((x)) & 0xFF); + data[index + 1] = (uint8_t)(((x) >> 8) & 0xFF); } -void emberAfCopyInt24u(uint8_t *data, uint16_t index, uint32_t x) +void emberAfCopyInt24u(uint8_t * data, uint16_t index, uint32_t x) { - data[index] = (uint8_t) ( ((x) ) & 0xFF); - data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); - data[index + 2] = (uint8_t) ( ((x) >> 16) & 0xFF); + data[index] = (uint8_t)(((x)) & 0xFF); + data[index + 1] = (uint8_t)(((x) >> 8) & 0xFF); + data[index + 2] = (uint8_t)(((x) >> 16) & 0xFF); } -void emberAfCopyInt32u(uint8_t *data, uint16_t index, uint32_t x) +void emberAfCopyInt32u(uint8_t * data, uint16_t index, uint32_t x) { - data[index] = (uint8_t) ( ((x) ) & 0xFF); - data[index + 1] = (uint8_t) ( ((x) >> 8) & 0xFF); - data[index + 2] = (uint8_t) ( ((x) >> 16) & 0xFF); - data[index + 3] = (uint8_t) ( ((x) >> 24) & 0xFF); + data[index] = (uint8_t)(((x)) & 0xFF); + data[index + 1] = (uint8_t)(((x) >> 8) & 0xFF); + data[index + 2] = (uint8_t)(((x) >> 16) & 0xFF); + data[index + 3] = (uint8_t)(((x) >> 24) & 0xFF); } -void emberAfCopyString(uint8_t *dest, uint8_t *src, uint8_t size) +void emberAfCopyString(uint8_t * dest, uint8_t * src, uint8_t size) { - if ( src == NULL ) { - dest[0] = 0; // Zero out the length of string - } else if (src[0] == 0xFF) { - dest[0] = src[0]; - } else { - uint8_t length = emberAfStringLength(src); - if (size < length) { - length = size; - } - MEMMOVE(dest + 1, src + 1, length); - dest[0] = length; - } + if (src == NULL) + { + dest[0] = 0; // Zero out the length of string + } + else if (src[0] == 0xFF) + { + dest[0] = src[0]; + } + else + { + uint8_t length = emberAfStringLength(src); + if (size < length) + { + length = size; + } + MEMMOVE(dest + 1, src + 1, length); + dest[0] = length; + } } -void emberAfCopyLongString(uint8_t *dest, uint8_t *src, uint16_t size) +void emberAfCopyLongString(uint8_t * dest, uint8_t * src, uint16_t size) { - if ( src == NULL ) { - dest[0] = dest[1] = 0; // Zero out the length of string - } else if ((src[0] == 0xFF) - && (src[1] == 0xFF)) { - dest[0] = 0xFF; - dest[1] = 0xFF; - } else { - uint16_t length = emberAfLongStringLength(src); - if (size < length) { - length = size; - } - MEMMOVE(dest + 2, src + 2, length); - dest[0] = LOW_BYTE(length); - dest[1] = HIGH_BYTE(length); - } + if (src == NULL) + { + dest[0] = dest[1] = 0; // Zero out the length of string + } + else if ((src[0] == 0xFF) && (src[1] == 0xFF)) + { + dest[0] = 0xFF; + dest[1] = 0xFF; + } + else + { + uint16_t length = emberAfLongStringLength(src); + if (size < length) + { + length = size; + } + MEMMOVE(dest + 2, src + 2, length); + dest[0] = LOW_BYTE(length); + dest[1] = HIGH_BYTE(length); + } } #if (BIGENDIAN_CPU) - #define EM_BIG_ENDIAN true +#define EM_BIG_ENDIAN true #else - #define EM_BIG_ENDIAN false +#define EM_BIG_ENDIAN false #endif // You can pass in val1 as NULL, which will assume that it is // pointing to an array of all zeroes. This is used so that // default value of NULL is treated as all zeroes. -int8_t emberAfCompareValues(uint8_t* val1, - uint8_t* val2, - uint8_t len, - bool signedNumber) +int8_t emberAfCompareValues(uint8_t * val1, uint8_t * val2, uint8_t len, bool signedNumber) { - uint8_t i, j, k; - if (signedNumber) { // signed number comparison - if (len <= 4) { // only number with 32-bits or less is supported - int32_t accum1 = 0x0; - int32_t accum2 = 0x0; - int32_t all1s = -1; - - for (i = 0; i < len; i++) { - j = (val1 == NULL - ? 0 - : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i]) - ); - accum1 |= j << (8 * (len - 1 - i)); - - k = (EM_BIG_ENDIAN - ? val2[i] - : val2[(len - 1) - i]); - accum2 |= k << (8 * (len - 1 - i)); - } - - // sign extending, no need for 32-bits numbers - if (len < 4) { - if ((accum1 & (1 << (8 * len - 1))) != 0) { // check sign - accum1 |= all1s - ((1 << (len * 8)) - 1); + uint8_t i, j, k; + if (signedNumber) + { // signed number comparison + if (len <= 4) + { // only number with 32-bits or less is supported + int32_t accum1 = 0x0; + int32_t accum2 = 0x0; + int32_t all1s = -1; + + for (i = 0; i < len; i++) + { + j = (val1 == NULL ? 0 : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i])); + accum1 |= j << (8 * (len - 1 - i)); + + k = (EM_BIG_ENDIAN ? val2[i] : val2[(len - 1) - i]); + accum2 |= k << (8 * (len - 1 - i)); + } + + // sign extending, no need for 32-bits numbers + if (len < 4) + { + if ((accum1 & (1 << (8 * len - 1))) != 0) + { // check sign + accum1 |= all1s - ((1 << (len * 8)) - 1); + } + if ((accum2 & (1 << (8 * len - 1))) != 0) + { // check sign + accum2 |= all1s - ((1 << (len * 8)) - 1); + } + } + + if (accum1 > accum2) + { + return 1; + } + else if (accum1 < accum2) + { + return -1; + } + else + { + return 0; + } } - if ((accum2 & (1 << (8 * len - 1))) != 0) { // check sign - accum2 |= all1s - ((1 << (len * 8)) - 1); + else + { // not supported + return 0; + } + } + else + { // regular unsigned number comparison + for (i = 0; i < len; i++) + { + j = (val1 == NULL ? 0 : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i])); + k = (EM_BIG_ENDIAN ? val2[i] : val2[(len - 1) - i]); + + if (j > k) + { + return 1; + } + else if (k > j) + { + return -1; + } + else + { + // MISRA requires ..else if.. to have terminating else. + } } - } - - if (accum1 > accum2) { - return 1; - } else if (accum1 < accum2) { - return -1; - } else { return 0; - } - } else { // not supported - return 0; - } - } else { // regular unsigned number comparison - for (i = 0; i < len; i++) { - j = (val1 == NULL - ? 0 - : (EM_BIG_ENDIAN ? val1[i] : val1[(len - 1) - i]) - ); - k = (EM_BIG_ENDIAN - ? val2[i] - : val2[(len - 1) - i]); - - if (j > k) { - return 1; - } else if (k > j) { - return -1; - } else { - // MISRA requires ..else if.. to have terminating else. - } } - return 0; - } } #if 0 @@ -1142,135 +1178,125 @@ int8_t emberAfCompareDates(EmberAfDate* date1, EmberAfDate* date2) // 2.15 from the ZCL spec 075123r02 uint8_t emberAfGetAttributeAnalogOrDiscreteType(uint8_t dataType) { - uint8_t index = 0; + uint8_t index = 0; - while ( emberAfAnalogDiscreteThresholds[index] < dataType ) { - index += 2; - } - return emberAfAnalogDiscreteThresholds[index + 1]; + while (emberAfAnalogDiscreteThresholds[index] < dataType) + { + index += 2; + } + return emberAfAnalogDiscreteThresholds[index + 1]; } // Zigbee spec says types between signed 8 bit and signed 64 bit bool emberAfIsTypeSigned(EmberAfAttributeType dataType) { - return (dataType >= ZCL_INT8S_ATTRIBUTE_TYPE - && dataType <= ZCL_INT64S_ATTRIBUTE_TYPE); + return (dataType >= ZCL_INT8S_ATTRIBUTE_TYPE && dataType <= ZCL_INT64S_ATTRIBUTE_TYPE); } -EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl *controls, - uint8_t endpoint) +EmberStatus emberAfEndpointEventControlSetInactive(EmberEventControl * controls, uint8_t endpoint) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index == 0xFF) { - return EMBER_INVALID_ENDPOINT; - } - //emberEventControlSetInactive(controls[index]); - return EMBER_SUCCESS; + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return EMBER_INVALID_ENDPOINT; + } + // emberEventControlSetInactive(controls[index]); + return EMBER_SUCCESS; } -bool emberAfEndpointEventControlGetActive(EmberEventControl *controls, - uint8_t endpoint) +bool emberAfEndpointEventControlGetActive(EmberEventControl * controls, uint8_t endpoint) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - return (index != 0xFF && false /*emberEventControlGetActive(controls[index])*/); + uint8_t index = emberAfIndexFromEndpoint(endpoint); + return (index != 0xFF && false /*emberEventControlGetActive(controls[index])*/); } -EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl *controls, - uint8_t endpoint) +EmberStatus emberAfEndpointEventControlSetActive(EmberEventControl * controls, uint8_t endpoint) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index == 0xFF) { - return EMBER_INVALID_ENDPOINT; - } - //emberEventControlSetActive(controls[index]); - return EMBER_SUCCESS; + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return EMBER_INVALID_ENDPOINT; + } + // emberEventControlSetActive(controls[index]); + return EMBER_SUCCESS; } -EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl *controls, - uint8_t endpoint, - uint32_t delayMs) +EmberStatus emberAfEndpointEventControlSetDelayMS(EmberEventControl * controls, uint8_t endpoint, uint32_t delayMs) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index == 0xFF) { - return EMBER_INVALID_ENDPOINT; - } - return emberAfEventControlSetDelayMS(&controls[index], delayMs); + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayMS(&controls[index], delayMs); } -EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl *controls, - uint8_t endpoint, - uint32_t delayQs) +EmberStatus emberAfEndpointEventControlSetDelayQS(EmberEventControl * controls, uint8_t endpoint, uint32_t delayQs) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index == 0xFF) { - return EMBER_INVALID_ENDPOINT; - } - return emberAfEventControlSetDelayQS(&controls[index], delayQs); + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayQS(&controls[index], delayQs); } -EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl *controls, - uint8_t endpoint, - uint16_t delayM) +EmberStatus emberAfEndpointEventControlSetDelayMinutes(EmberEventControl * controls, uint8_t endpoint, uint16_t delayM) { - uint8_t index = emberAfIndexFromEndpoint(endpoint); - if (index == 0xFF) { - return EMBER_INVALID_ENDPOINT; - } - return emberAfEventControlSetDelayMinutes(&controls[index], delayM); + uint8_t index = emberAfIndexFromEndpoint(endpoint); + if (index == 0xFF) + { + return EMBER_INVALID_ENDPOINT; + } + return emberAfEventControlSetDelayMinutes(&controls[index], delayM); } bool emberAfIsThisMyEui64(EmberEUI64 eui64) { - EmberEUI64 myEui64; - emberAfGetEui64(myEui64); - return (0 == MEMCOMPARE(eui64, myEui64, EUI64_SIZE) - ? true - : false); + EmberEUI64 myEui64; + emberAfGetEui64(myEui64); + return (0 == MEMCOMPARE(eui64, myEui64, EUI64_SIZE) ? true : false); } -uint8_t emberAfAppendCharacters(uint8_t * zclString, - uint8_t zclStringMaxLen, - const uint8_t * appendingChars, +uint8_t emberAfAppendCharacters(uint8_t * zclString, uint8_t zclStringMaxLen, const uint8_t * appendingChars, uint8_t appendingCharsLen) { - uint8_t freeChars; - uint8_t curLen; - uint8_t charsToWrite; - - if ((zclString == NULL) - || (zclStringMaxLen == 0) - || (appendingChars == NULL) - || (appendingCharsLen == 0)) { - return 0; - } - - curLen = emberAfStringLength(zclString); - - if ((zclString[0] == 0xFF) - || (curLen >= zclStringMaxLen)) { - return 0; - } - - freeChars = zclStringMaxLen - curLen; - charsToWrite = (freeChars > appendingCharsLen) ? appendingCharsLen : freeChars; - - MEMCOPY(&zclString[1 + curLen], // 1 is to account for zcl's length byte - appendingChars, - charsToWrite); - zclString[0] = curLen + charsToWrite; - return charsToWrite; + uint8_t freeChars; + uint8_t curLen; + uint8_t charsToWrite; + + if ((zclString == NULL) || (zclStringMaxLen == 0) || (appendingChars == NULL) || (appendingCharsLen == 0)) + { + return 0; + } + + curLen = emberAfStringLength(zclString); + + if ((zclString[0] == 0xFF) || (curLen >= zclStringMaxLen)) + { + return 0; + } + + freeChars = zclStringMaxLen - curLen; + charsToWrite = (freeChars > appendingCharsLen) ? appendingCharsLen : freeChars; + + MEMCOPY(&zclString[1 + curLen], // 1 is to account for zcl's length byte + appendingChars, charsToWrite); + zclString[0] = curLen + charsToWrite; + return charsToWrite; } -uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initialValue) +uint32_t emberAfGetBufferCrc(uint8_t * pbuffer, uint16_t length, uint32_t initialValue) { - uint16_t i; - uint32_t crc32 = initialValue; - for (i = 0; i < length; i++) { - // Crash so we don't reach this code by accident. - *(int*)0 = 5; - // crc32 = halCommonCrc32(pbuffer[i], crc32); - } - return crc32; + uint16_t i; + uint32_t crc32 = initialValue; + for (i = 0; i < length; i++) + { + // Crash so we don't reach this code by accident. + *(int *) 0 = 5; + // crc32 = halCommonCrc32(pbuffer[i], crc32); + } + return crc32; } /* @@ -1285,94 +1311,101 @@ uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initial */ EmberStatus emAfValidateChannelPages(uint8_t page, uint8_t channel) { - switch (page) { + switch (page) + { case 0: - if (!((channel <= EMBER_MAX_802_15_4_CHANNEL_NUMBER) - && ((EMBER_MIN_802_15_4_CHANNEL_NUMBER == 0) - || (channel >= EMBER_MIN_802_15_4_CHANNEL_NUMBER)))) { - return EMBER_PHY_INVALID_CHANNEL; - } - break; + if (!((channel <= EMBER_MAX_802_15_4_CHANNEL_NUMBER) && + ((EMBER_MIN_802_15_4_CHANNEL_NUMBER == 0) || (channel >= EMBER_MIN_802_15_4_CHANNEL_NUMBER)))) + { + return EMBER_PHY_INVALID_CHANNEL; + } + break; case 28: case 30: case 31: - if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31) { - return EMBER_PHY_INVALID_CHANNEL; - } - break; + if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31) + { + return EMBER_PHY_INVALID_CHANNEL; + } + break; case 29: - if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29) { - return EMBER_PHY_INVALID_CHANNEL; - } - break; + if (channel > EMBER_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29) + { + return EMBER_PHY_INVALID_CHANNEL; + } + break; default: - return EMBER_PHY_INVALID_CHANNEL; - break; - } - return EMBER_SUCCESS; + return EMBER_PHY_INVALID_CHANNEL; + break; + } + return EMBER_SUCCESS; } void slabAssert(const char * file, int line) { - (void)file; // Unused parameter - (void)line; // Unused parameter - // Wait forever until the watchdog fires - while (true) { - } + (void) file; // Unused parameter + (void) line; // Unused parameter + // Wait forever until the watchdog fires + while (true) + { + } } -#define ENCODED_8BIT_CHANPG_PAGE_MASK 0xE0 // top 3 bits -#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0 0x00 // 0b000xxxxx -#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28 0x80 // 0b100xxxxx -#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29 0xA0 // 0b101xxxxx -#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30 0xC0 // 0b110xxxxx -#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31 0xE0 // 0b111xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK 0xE0 // top 3 bits +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0 0x00 // 0b000xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28 0x80 // 0b100xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29 0xA0 // 0b101xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30 0xC0 // 0b110xxxxx +#define ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31 0xE0 // 0b111xxxxx -#define ENCODED_8BIT_CHANPG_CHANNEL_MASK 0x1F // bottom 5 bits +#define ENCODED_8BIT_CHANPG_CHANNEL_MASK 0x1F // bottom 5 bits uint8_t emberAfGetPageFrom8bitEncodedChanPg(uint8_t chanPg) { - switch (chanPg & ENCODED_8BIT_CHANPG_PAGE_MASK) { + switch (chanPg & ENCODED_8BIT_CHANPG_PAGE_MASK) + { case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0: - return 0; + return 0; case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28: - return 28; + return 28; case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29: - return 29; + return 29; case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30: - return 30; + return 30; case ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31: - return 31; + return 31; default: - return 0xFF; - } + return 0xFF; + } } uint8_t emberAfGetChannelFrom8bitEncodedChanPg(uint8_t chanPg) { - return chanPg & ENCODED_8BIT_CHANPG_CHANNEL_MASK; + return chanPg & ENCODED_8BIT_CHANPG_CHANNEL_MASK; } uint8_t emberAfMake8bitEncodedChanPg(uint8_t page, uint8_t channel) { - if (emAfValidateChannelPages(page, channel) != EMBER_SUCCESS) { - return 0xFF; - } + if (emAfValidateChannelPages(page, channel) != EMBER_SUCCESS) + { + return 0xFF; + } - switch (page) { + switch (page) + { case 28: - return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28; + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_28; case 29: - return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29; + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_29; case 30: - return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30; + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_30; case 31: - return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31; + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_31; default: - // Strictly speaking, we only need case 0 here, but MISRA in its infinite - // wisdom requires a default case. Since we have validated the arguments - // already, and 0 is the only remaining case, we simply treat the default - // as case 0 to make MISRA happy. - return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0; - } + // Strictly speaking, we only need case 0 here, but MISRA in its infinite + // wisdom requires a default case. Since we have validated the arguments + // already, and 0 is the only remaining case, we simply treat the default + // as case 0 to make MISRA happy. + return channel | ENCODED_8BIT_CHANPG_PAGE_MASK_PAGE_0; + } } diff --git a/examples/wifi-echo/server/esp32/main/util.h b/examples/wifi-echo/server/esp32/main/util.h index 949a63a6c09c9e..c87ddeddef0b96 100644 --- a/examples/wifi-echo/server/esp32/main/util.h +++ b/examples/wifi-echo/server/esp32/main/util.h @@ -31,11 +31,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -/***************************************************************************//** +/***************************************************************************/ +/** * @file * @brief ******************************************************************************* - ******************************************************************************/ + ******************************************************************************/ // ******************************************************************* // * util.h @@ -52,29 +53,28 @@ // #define USER_ASSERT(file, line) userAssert(file, line) // definition #if defined(NO_ASSERT) - #define SLAB_ASSERT(expr) +#define SLAB_ASSERT(expr) +#else +#if defined(USER_ASSERT) +#define SLAB_ASSERT(expr) ((expr) ? ((void) 0) : USER_ASSERT(__FILE__, __LINE__)) #else - #if defined(USER_ASSERT) - #define SLAB_ASSERT(expr) \ - ((expr) ? ((void)0) : USER_ASSERT(__FILE__, __LINE__)) - #else - #define SLAB_ASSERT(expr) \ - ((expr) ? ((void)0) : slabAssert(__FILE__, __LINE__)) - #endif // USER_ASSERT +#define SLAB_ASSERT(expr) ((expr) ? ((void) 0) : slabAssert(__FILE__, __LINE__)) +#endif // USER_ASSERT #endif // NO_ASSERT // This controls the type of response. Normally The library sends an automatic // response (if appropriate) on the same PAN. The reply can be disabled by // calling emberAfSetNoReplyForNextMessage. -#define ZCL_UTIL_RESP_NORMAL 0 -#define ZCL_UTIL_RESP_NONE 1 +#define ZCL_UTIL_RESP_NORMAL 0 +#define ZCL_UTIL_RESP_NONE 1 #define ZCL_UTIL_RESP_INTERPAN 2 // Cluster name structure -typedef struct { - uint16_t id; - uint16_t mfgCode; - const char * name; +typedef struct +{ + uint16_t id; + uint16_t mfgCode; + const char * name; } EmberAfClusterName; extern const EmberAfClusterName zclClusterNames[]; @@ -84,10 +84,11 @@ extern const EmberAfClusterName zclClusterNames[]; #include "af.h" // Override APS retry: 0 - don't touch, 1 - always set, 2 - always unset -typedef enum { - EMBER_AF_RETRY_OVERRIDE_NONE = 0, - EMBER_AF_RETRY_OVERRIDE_SET = 1, - EMBER_AF_RETRY_OVERRIDE_UNSET = 2 +typedef enum +{ + EMBER_AF_RETRY_OVERRIDE_NONE = 0, + EMBER_AF_RETRY_OVERRIDE_SET = 1, + EMBER_AF_RETRY_OVERRIDE_UNSET = 2 } EmberAfRetryOverride; // The default APS retry flag value is controlled by EMBER_AF_DEFAULT_APS_OPTIONS @@ -105,13 +106,14 @@ EmberAfRetryOverride emberAfGetRetryOverride(void); // This function applies the curent override value to the APS options. // It is called internally by the framework in the final stages of filling the // message buffer. -void emAfApplyRetryOverride(EmberApsOption *options); +void emAfApplyRetryOverride(EmberApsOption * options); // Override Disable Default Response flag in the ZCL Frame Control -typedef enum { - EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE = 0, // no override - EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT = 1, // next message only - EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT = 2 // until cancelled +typedef enum +{ + EMBER_AF_DISABLE_DEFAULT_RESPONSE_NONE = 0, // no override + EMBER_AF_DISABLE_DEFAULT_RESPONSE_ONE_SHOT = 1, // next message only + EMBER_AF_DISABLE_DEFAULT_RESPONSE_PERMANENT = 2 // until cancelled } EmberAfDisableDefaultResponse; // The default value for the Disable Default Response flag in ZCL Frame Control @@ -126,7 +128,7 @@ EmberAfDisableDefaultResponse emberAfGetDisableDefaultResponse(void); // This function applies the curent override value to the ZCL Frame Control. // It is called internally by the framework in the final stages of filling the // message buffer. -void emAfApplyDisableDefaultResponse(uint8_t *frame_control); +void emAfApplyDisableDefaultResponse(uint8_t * frame_control); // Returns a mfg code from current command. // This should only be used within the command parsing context. @@ -147,20 +149,12 @@ void emberAfStackDown(void); void emberAfDecodeAndPrintCluster(uint16_t cluster); void emberAfDecodeAndPrintClusterWithMfgCode(uint16_t cluster, uint16_t mfgCode); -bool emberAfProcessMessage(EmberApsFrame *apsFrame, - EmberIncomingMessageType type, - uint8_t *message, - uint16_t msgLen, - EmberNodeId source, - InterPanHeader *interPanHeader); - -bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, - EmberIncomingMessageType type, - uint8_t* message, - uint16_t messageLength, - EmberNodeId source, - InterPanHeader* interPanHeader, - EmberAfClusterCommand* returnCmd); +bool emberAfProcessMessage(EmberApsFrame * apsFrame, EmberIncomingMessageType type, uint8_t * message, uint16_t msgLen, + EmberNodeId source, InterPanHeader * interPanHeader); + +bool emberAfProcessMessageIntoZclCmd(EmberApsFrame * apsFrame, EmberIncomingMessageType type, uint8_t * message, + uint16_t messageLength, EmberNodeId source, InterPanHeader * interPanHeader, + EmberAfClusterCommand * returnCmd); /** * Retrieves the difference between the two passed values. @@ -169,9 +163,7 @@ bool emberAfProcessMessageIntoZclCmd(EmberApsFrame* apsFrame, * on data sizes up to 8 bytes. Otherwise, it will only work on data sizes of * up to 4 bytes. */ -EmberAfDifferenceType emberAfGetDifference(uint8_t* pData, - EmberAfDifferenceType value, - uint8_t dataSize); +EmberAfDifferenceType emberAfGetDifference(uint8_t * pData, EmberAfDifferenceType value, uint8_t dataSize); /** * Retrieves an uint32_t from the given Zigbee payload. The integer retrieved @@ -184,27 +176,28 @@ EmberAfDifferenceType emberAfGetDifference(uint8_t* pData, * the retrieval of integers between 1 and 4 bytes in length. * */ -uint32_t emberAfGetInt(const uint8_t* message, uint16_t currentIndex, uint16_t msgLen, uint8_t bytes); +uint32_t emberAfGetInt(const uint8_t * message, uint16_t currentIndex, uint16_t msgLen, uint8_t bytes); void emberAfClearResponseData(void); -uint8_t * emberAfPutInt8uInResp(uint8_t value); +uint8_t * emberAfPutInt8uInResp(uint8_t value); uint16_t * emberAfPutInt16uInResp(uint16_t value); uint32_t * emberAfPutInt32uInResp(uint32_t value); uint32_t * emberAfPutInt24uInResp(uint32_t value); -uint8_t * emberAfPutBlockInResp(const uint8_t* data, uint16_t length); -uint8_t * emberAfPutStringInResp(const uint8_t *buffer); -uint8_t * emberAfPutDateInResp(EmberAfDate *value); +uint8_t * emberAfPutBlockInResp(const uint8_t * data, uint16_t length); +uint8_t * emberAfPutStringInResp(const uint8_t * buffer); +uint8_t * emberAfPutDateInResp(EmberAfDate * value); bool emberAfIsThisMyEui64(EmberEUI64 eui64); -uint32_t emberAfGetBufferCrc(uint8_t *pbuffer, uint16_t length, uint32_t initialValue); +uint32_t emberAfGetBufferCrc(uint8_t * pbuffer, uint16_t length, uint32_t initialValue); // If the variable has not been set, APS_TEST_SECURITY_DEFAULT will // eventually return false. -enum { - APS_TEST_SECURITY_ENABLED = 0, - APS_TEST_SECURITY_DISABLED = 1, - APS_TEST_SECURITY_DEFAULT = 2, +enum +{ + APS_TEST_SECURITY_ENABLED = 0, + APS_TEST_SECURITY_DISABLED = 1, + APS_TEST_SECURITY_DEFAULT = 2, }; extern uint8_t emAfTestApsSecurityOverride; @@ -213,7 +206,7 @@ extern uint8_t emAfTestApsSecurityOverride; // a cluster that needs it. EmberNodeId emberGetSender(void); EmberStatus emberGetSenderEui64(EmberEUI64 senderEui64); -#endif //EZSP_HOST +#endif // EZSP_HOST // DEPRECATED. extern uint8_t emberAfIncomingZclSequenceNumber; @@ -228,22 +221,17 @@ void emberAfSetNoReplyForNextMessage(bool set); // this function determines if APS Link key should be used to secure // the message. It is based on the clusterId and specified in the SE // app profile. If the message is outgoing then the -bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, - bool incoming, - bool broadcast, - EmberAfProfileId profileId, - EmberAfClusterId clusterId, - EmberNodeId remoteNodeId); +bool emberAfDetermineIfLinkSecurityIsRequired(uint8_t commandId, bool incoming, bool broadcast, EmberAfProfileId profileId, + EmberAfClusterId clusterId, EmberNodeId remoteNodeId); -#define isThisDataTypeSentLittleEndianOTA(dataType) \ - (!(emberAfIsThisDataTypeAStringType(dataType))) +#define isThisDataTypeSentLittleEndianOTA(dataType) (!(emberAfIsThisDataTypeAStringType(dataType))) -bool emAfProcessGlobalCommand(EmberAfClusterCommand *cmd); -bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand *cmd); +bool emAfProcessGlobalCommand(EmberAfClusterCommand * cmd); +bool emAfProcessClusterSpecificCommand(EmberAfClusterCommand * cmd); extern uint8_t emberAfResponseType; -uint16_t emberAfStrnlen(const uint8_t* string, uint16_t maxLength); +uint16_t emberAfStrnlen(const uint8_t * string, uint16_t maxLength); /* @brief Append characters to a ZCL string. * @@ -258,9 +246,7 @@ uint16_t emberAfStrnlen(const uint8_t* string, uint16_t maxLength); * @return number of characters appended * */ -uint8_t emberAfAppendCharacters(uint8_t * zclString, - uint8_t zclStringMaxLen, - const uint8_t * appendingChars, +uint8_t emberAfAppendCharacters(uint8_t * zclString, uint8_t zclStringMaxLen, const uint8_t * appendingChars, uint8_t appendingCharsLen); extern uint8_t emAfExtendedPanId[]; From 76aa9b0254516837fec58121d6e316a562707acc Mon Sep 17 00:00:00 2001 From: Bhaskar Sarma Date: Thu, 2 Jul 2020 16:21:45 -0700 Subject: [PATCH 09/12] Add utilities for encoding and decoding messages that the Silicon Labs ZigbeePro implementation can handle. The actual encoding we are using is not quite the APS encoding, but it's still a throwaway, so that does not matter too much. --- configure.ac | 1 + src/app/BUILD.gn | 10 ++ src/app/DataModel.am | 2 + src/app/Makefile.am | 1 + src/app/chip-zcl-zpro/Makefile.am | 31 ++++ .../command-encoder/chip-zcl-zpro-codec.h | 85 +++++++++ .../chip-zcl-zpro/command-encoder/decoder.c | 124 ++++++++++++++ .../chip-zcl-zpro/command-encoder/encoder.c | 162 ++++++++++++++++++ 8 files changed, 416 insertions(+) create mode 100644 src/app/chip-zcl-zpro/Makefile.am create mode 100644 src/app/chip-zcl-zpro/command-encoder/chip-zcl-zpro-codec.h create mode 100644 src/app/chip-zcl-zpro/command-encoder/decoder.c create mode 100644 src/app/chip-zcl-zpro/command-encoder/encoder.c diff --git a/configure.ac b/configure.ac index 7de7422dba5c07..8d840c436fc3dc 100644 --- a/configure.ac +++ b/configure.ac @@ -2304,6 +2304,7 @@ src/Makefile src/include/Makefile src/app/Makefile src/app/chip-zcl/Makefile +src/app/chip-zcl-zpro/Makefile src/app/gen/Makefile src/app/plugin/Makefile src/app/plugin/tests/Makefile diff --git a/src/app/BUILD.gn b/src/app/BUILD.gn index d8bf6362474134..5f58643edabb99 100644 --- a/src/app/BUILD.gn +++ b/src/app/BUILD.gn @@ -19,6 +19,7 @@ config("app_config") { "gen", "chip-zcl", ".", + "${target_gen_dir}/include", ] } @@ -26,6 +27,8 @@ static_library("common") { output_name = "libCHIPDataModelCommon" sources = [ + "chip-zcl-zpro/command-encoder/encoder.c", + "chip-zcl-zpro/command-encoder/decoder.c", "chip-zcl/chip-zcl-buffer.h", "chip-zcl/chip-zcl-codec.h", "chip-zcl/chip-zcl-struct.h", @@ -62,6 +65,7 @@ static_library("common") { public_deps = [ "${chip_root}/src/lib/support", "${chip_root}/src/system", + ":codec_headers", ] public_configs = [ ":app_config" ] @@ -86,3 +90,9 @@ static_library("mock") { group("app") { public_deps = [ ":chip" ] } + +copy("codec_headers") { + sources = [ "chip-zcl-zpro/command-encoder/chip-zcl-zpro-codec.h" ] + + outputs = [ "${target_gen_dir}/include/chip-zcl/{{source_file_part}}" ] +} diff --git a/src/app/DataModel.am b/src/app/DataModel.am index a47712372857c0..eda008cc3f5546 100644 --- a/src/app/DataModel.am +++ b/src/app/DataModel.am @@ -38,6 +38,8 @@ CHIP_BUILD_DATA_MODEL_SOURCE_FILES @top_builddir@/src/app/plugin/core-api/core-api.c \ @top_builddir@/src/app/plugin/core-data-model/zcl-data-model.c \ @top_builddir@/src/app/plugin/core-message-dispatch/dispatch.c \ + @top_builddir@/src/app/chip-zcl-zpro/command-encoder/encoder.c \ + @top_builddir@/src/app/chip-zcl-zpro/command-encoder/decoder.c \ $(NULL) # Excluding this one for now because it has #include syntax that does diff --git a/src/app/Makefile.am b/src/app/Makefile.am index 2dc0aadd146a59..4a2f52f51a9e41 100644 --- a/src/app/Makefile.am +++ b/src/app/Makefile.am @@ -26,6 +26,7 @@ include $(abs_top_nlbuild_autotools_dir)/automake/pre.am SUBDIRS = \ gen \ chip-zcl \ + chip-zcl-zpro \ plugin \ $(NULL) diff --git a/src/app/chip-zcl-zpro/Makefile.am b/src/app/chip-zcl-zpro/Makefile.am new file mode 100644 index 00000000000000..8cdf8b0c3e7173 --- /dev/null +++ b/src/app/chip-zcl-zpro/Makefile.am @@ -0,0 +1,31 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# +# Description: +# This file exports the CHIP ZCL Application layer API headers +# for install and dist targets +# + +include $(abs_top_nlbuild_autotools_dir)/automake/pre.am + +chip_zcldir = $(includedir)/chip-zcl + +chip_zcl_HEADERS = \ + command-encoder/chip-zcl-zpro-codec.h \ + $(NULL) + +include $(abs_top_nlbuild_autotools_dir)/automake/post.am diff --git a/src/app/chip-zcl-zpro/command-encoder/chip-zcl-zpro-codec.h b/src/app/chip-zcl-zpro/command-encoder/chip-zcl-zpro-codec.h new file mode 100644 index 00000000000000..9fa43160866f02 --- /dev/null +++ b/src/app/chip-zcl-zpro/command-encoder/chip-zcl-zpro-codec.h @@ -0,0 +1,85 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CHIP_ZCL_ZPRO_CODEC_H +#define CHIP_ZCL_ZPRO_CODEC_H + +#include +#include + +typedef uint16_t EmberApsOption; + +/** @brief An in-memory representation of a ZigBee APS frame + * of an incoming or outgoing message. Copy pasted here so that we can compile this unit of code independently. + */ +typedef struct +{ + /** The application profile ID that describes the format of the message. */ + uint16_t profileId; + /** The cluster ID for this message. */ + uint16_t clusterId; + /** The source endpoint. */ + uint8_t sourceEndpoint; + /** The destination endpoint. */ + uint8_t destinationEndpoint; + /** A bitmask of options from the enumeration above. */ + EmberApsOption options; + /** The group ID for this message, if it is multicast mode. */ + uint16_t groupId; + /** The sequence number. */ + uint8_t sequence; + uint8_t radius; +} EmberApsFrame; + +#ifdef __cplusplus +extern "C" { +#endif + +/** @brief Encode an on command for on-off server into buffer including the APS frame + */ +uint32_t encodeOnCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint); + +/** @brief Encode an off command for on-off server into buffer including the APS frame + */ + +uint32_t encodeOffCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint); + +/** @brief Encode a toggle command for on-off server into buffer including the APS frame + */ + +uint32_t encodeToggleCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint); + +/** @brief Extracts an aps frame from buffer into outApsFrame + */ +bool extractApsFrame(void * buffer, uint32_t buf_length, EmberApsFrame * outApsFrame); + +/** @brief Extracts an aps frame from buffer into outApsFrame. Returns the length of the msg. + */ +uint32_t extractMessage(void * buffer, void ** msg); + +/** @brief Prints an aps frame struct + */ +void printApsFrame(EmberApsFrame * frame); + +/** @brief Prints commmand information. Assumes buffer was encoded using one of encode(On|Off|Toggle)Command function + */ +void printCommandInfo(void * buffer); +#ifdef __cplusplus +} +#endif + +#endif // CHIP_ZCL_ZPRO_CODEC_H diff --git a/src/app/chip-zcl-zpro/command-encoder/decoder.c b/src/app/chip-zcl-zpro/command-encoder/decoder.c new file mode 100644 index 00000000000000..3d9b2886a9f0f6 --- /dev/null +++ b/src/app/chip-zcl-zpro/command-encoder/decoder.c @@ -0,0 +1,124 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// bool emberAfProcessMessage(EmberApsFrame *apsFrame, +// EmberIncomingMessageType type, +// uint8_t *message, +// uint16_t msgLen, +// EmberNodeId source, +// InterPanHeader *interPanHeader) + +#include "chip-zcl-zpro-codec.h" +#include +#include + +// TODO: Make this return a CHIP_ERROR +bool extractApsFrame(void * buffer, uint32_t buf_length, EmberApsFrame * outApsFrame) +{ + if (buffer == NULL || buf_length == 0 || outApsFrame == NULL) + { + return false; + } + // Skip first byte, because that's the always-0 frame control. + uint8_t nextByteToRead = 1; + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->profileId, buffer + nextByteToRead, sizeof(outApsFrame->profileId)); + nextByteToRead += sizeof(outApsFrame->profileId); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->clusterId, buffer + nextByteToRead, sizeof(outApsFrame->clusterId)); + nextByteToRead += sizeof(outApsFrame->clusterId); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->sourceEndpoint, buffer + nextByteToRead, sizeof(outApsFrame->sourceEndpoint)); + nextByteToRead += sizeof(outApsFrame->sourceEndpoint); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->destinationEndpoint, buffer + nextByteToRead, sizeof(outApsFrame->destinationEndpoint)); + nextByteToRead += sizeof(outApsFrame->destinationEndpoint); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->options, buffer + nextByteToRead, sizeof(outApsFrame->options)); + nextByteToRead += sizeof(outApsFrame->options); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->groupId, buffer + nextByteToRead, sizeof(outApsFrame->groupId)); + nextByteToRead += sizeof(outApsFrame->groupId); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->sequence, buffer + nextByteToRead, sizeof(outApsFrame->sequence)); + nextByteToRead += sizeof(outApsFrame->sequence); + + if (nextByteToRead >= buf_length) + { + return false; + } + memcpy(&outApsFrame->radius, buffer + nextByteToRead, sizeof(outApsFrame->radius)); + nextByteToRead += sizeof(outApsFrame->radius); + + return true; +} + +void printApsFrame(EmberApsFrame * frame) +{ + printf("\n profileID %d, clusterID %d, sourceEndpoint %d, destinationEndPoint %d, options %d, groupID %d, " + "sequence %d, radius %d\n", + frame, frame->profileId, frame->clusterId, frame->sourceEndpoint, frame->destinationEndpoint, frame->options, + frame->groupId, frame->sequence, frame->radius); +} + +void printCommandInfo(void * buffer) +{ + void * msg = NULL; + extractMessage(buffer, &msg); + uint8_t val = (uint8_t) * ((uint8_t *) (msg + 2)); + printf("Encoded command id %d\n", val); +} + +uint32_t extractMessage(void * buffer, void ** msg) +{ + uint32_t result = 0; + if (msg) + { + // These are hard coded for now. + *msg = buffer + 13; + result = 3; + } + return result; +} diff --git a/src/app/chip-zcl-zpro/command-encoder/encoder.c b/src/app/chip-zcl-zpro/command-encoder/encoder.c new file mode 100644 index 00000000000000..1c1a0822e3f3d6 --- /dev/null +++ b/src/app/chip-zcl-zpro/command-encoder/encoder.c @@ -0,0 +1,162 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "chip-zcl-zpro-codec.h" +#include +#include + +uint32_t encodeApsFrame(uint8_t * buffer, uint32_t buf_length, uint16_t profileID, uint16_t clusterId, uint8_t sourceEndpoint, + uint8_t destinationEndpoint, EmberApsOption options, uint16_t groupId, uint8_t sequence, uint8_t radius) +{ + uint32_t size = 0; + if (buffer == NULL || buf_length == 0) + { + return size; + } + size_t nextOutByte = 0; + + if (nextOutByte >= buf_length) + { + return size; + } + + // Simulated APS "frame control" byte. + buffer[nextOutByte] = 0; + ++nextOutByte; + + if (nextOutByte >= buf_length) + { + return size; + } + + memcpy(buffer + nextOutByte, &profileID, sizeof(uint16_t)); + nextOutByte += sizeof(uint16_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &clusterId, sizeof(uint16_t)); + nextOutByte += sizeof(uint16_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &sourceEndpoint, sizeof(uint8_t)); + nextOutByte += sizeof(uint8_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &destinationEndpoint, sizeof(uint8_t)); + nextOutByte += sizeof(uint8_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &options, sizeof(EmberApsOption)); + nextOutByte += sizeof(EmberApsOption); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &groupId, sizeof(uint16_t)); + nextOutByte += sizeof(uint16_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &sequence, sizeof(uint8_t)); + nextOutByte += sizeof(uint8_t); + + if (nextOutByte >= buf_length) + { + return size; + } + memcpy(buffer + nextOutByte, &radius, sizeof(uint8_t)); + nextOutByte += sizeof(uint8_t); + + buf_length = nextOutByte; + printf("Encoded %d bytes of aps frame\n", buf_length); + return buf_length; +} + +uint32_t _encodeOnOffCommand(uint8_t * buffer, uint32_t buf_length, int command, uint8_t destination_endpoint) +{ + uint32_t result = 0; + // pick cluster id as 6 for now. + // pick source and destination end points as 1 for now. + // Profile is 65535 because that matches our simple generated code, but we + // should sort out the profile situation. + result = encodeApsFrame(buffer, buf_length, 65535, 6, 1, destination_endpoint, 0, 0, 0, 0); + if (result == 0 || result > buf_length) + { + printf("Error encoding aps frame result %d", result); + result = 0; + return result; + } + uint32_t indexToWrite = result; + // This is a cluster-specific command so low two bits are 0b01. The command + // is standard, so does not need a manufacturer code, and we're sending + // client to server, so all the remaining bits are 0. + + uint8_t * val = buffer + indexToWrite++; + *val = 0x1; + + if (indexToWrite >= buf_length) + { + printf("indexToWrite %d\n", indexToWrite); + return 0; + } + // Transaction sequence number. Just pick something. + val = buffer + indexToWrite++; + *val = 0x1; + + if (indexToWrite >= buf_length) + { + return 0; + } + + val = buffer + indexToWrite++; + *val = command; + + if (indexToWrite >= buf_length) + { + return 0; + } + return indexToWrite; +} + +uint32_t encodeOffCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint) +{ + return _encodeOnOffCommand(buffer, buf_length, 0, destination_endpoint); +}; + +uint32_t encodeOnCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint) +{ + return _encodeOnOffCommand(buffer, buf_length, 1, destination_endpoint); +} + +uint32_t encodeToggleCommand(uint8_t * buffer, uint32_t buf_length, uint8_t destination_endpoint) +{ + return _encodeOnOffCommand(buffer, buf_length, 2, destination_endpoint); +} From b847240ab9600431908e5788af38c18ecc63cca2 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Wed, 8 Jul 2020 15:59:58 -0400 Subject: [PATCH 10/12] Switch the echo server to using the new On/Off implementation. We no longer compile the Dotdot-based ZCL data model files into libCHIP, because those have symbols whose names conflict with the new ZigbeePro-based ZCL data model files. --- config/nrf5/nrf5-chip.mk | 1 + .../server/esp32/main/CHIPDeviceManager.cpp | 2 +- .../server/esp32/main/DataModelHandler.cpp | 45 +++++++++++++++---- .../server/esp32/main/EchoDeviceCallbacks.cpp | 11 +++-- .../server/esp32/main/gen/callback-stub.c | 8 ++++ .../esp32/main/include/CHIPDeviceManager.h | 8 ++-- .../esp32/main/include/EchoDeviceCallbacks.h | 2 +- .../wifi-echo/server/esp32/main/types_stub.h | 24 +--------- src/app/DataModel.am | 5 ++- src/app/Makefile.am | 5 ++- 10 files changed, 69 insertions(+), 42 deletions(-) diff --git a/config/nrf5/nrf5-chip.mk b/config/nrf5/nrf5-chip.mk index 38ea27e1bf232d..1d6ff88e793e74 100644 --- a/config/nrf5/nrf5-chip.mk +++ b/config/nrf5/nrf5-chip.mk @@ -149,6 +149,7 @@ STD_LDFLAGS += -L$(CHIP_OUTPUT_DIR)/lib STD_LIBS += \ -lDeviceLayer \ -lCHIP \ + -lCHIPDataModel \ -lInetLayer \ -lSystemLayer \ -llwip diff --git a/examples/wifi-echo/server/esp32/main/CHIPDeviceManager.cpp b/examples/wifi-echo/server/esp32/main/CHIPDeviceManager.cpp index c5f8d57e81ad8d..22b9f628b5ce88 100644 --- a/examples/wifi-echo/server/esp32/main/CHIPDeviceManager.cpp +++ b/examples/wifi-echo/server/esp32/main/CHIPDeviceManager.cpp @@ -85,7 +85,7 @@ CHIP_ERROR CHIPDeviceManager::Init(CHIPDeviceManagerCallbacks * cb) } extern "C" { -void chipZclPostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, uint8_t mask, +void emberAfPostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) { CHIPDeviceManagerCallbacks * cb = CHIPDeviceManager::GetInstance().GetCHIPDeviceManagerCallbacks(); diff --git a/examples/wifi-echo/server/esp32/main/DataModelHandler.cpp b/examples/wifi-echo/server/esp32/main/DataModelHandler.cpp index 82dfdec73c1a3c..9035deee5106be 100644 --- a/examples/wifi-echo/server/esp32/main/DataModelHandler.cpp +++ b/examples/wifi-echo/server/esp32/main/DataModelHandler.cpp @@ -27,9 +27,12 @@ #include "LEDWidget.h" extern "C" { -#include "chip-zcl/chip-zcl.h" -#include "gen/gen-cluster-id.h" -#include "gen/gen-types.h" +#include "attribute-storage.h" +#include "chip-zcl/chip-zcl-zpro-codec.h" +#include "gen/attribute-id.h" +#include "gen/cluster-id.h" +#include "gen/znet-bookkeeping.h" +#include "util.h" } using namespace ::chip; @@ -38,19 +41,45 @@ static const char * TAG = "data_model_server"; void InitDataModelHandler() { - chipZclEndpointInit(); + emberAfEndpointConfigure(); + emAfInit(); } void HandleDataModelMessage(System::PacketBuffer * buffer) { - ChipZclStatus_t zclStatus = chipZclProcessIncoming((ChipZclBuffer_t *) buffer); - if (zclStatus == CHIP_ZCL_STATUS_SUCCESS) + EmberApsFrame frame; + bool ok = extractApsFrame(buffer->Start(), buffer->DataLength(), &frame); + if (ok) { - ESP_LOGI(TAG, "Data model processing success!"); + ESP_LOGI(TAG, "APS frame processing success!"); } else { - ESP_LOGI(TAG, "Data model processing failure: %d", zclStatus); + ESP_LOGI(TAG, "APS frame processing failure"); + System::PacketBuffer::Free(buffer); + return; } + + // FIXME: Callee needs to be told the buffer length, so it can fail out if + // we don't have enough buffer!!! + void * raw_message; + uint32_t messageLen = extractMessage(buffer->Start(), &raw_message); + auto message = static_cast(raw_message); + + ok = emberAfProcessMessage(&frame, + 0, // type + message, messageLen, + 0, // source node id + NULL); + System::PacketBuffer::Free(buffer); + + if (ok) + { + ESP_LOGI(TAG, "Data model processing success!"); + } + else + { + ESP_LOGI(TAG, "Data model processing failure"); + } } diff --git a/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp b/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp index 1428c770658635..000bad04af4438 100644 --- a/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp +++ b/examples/wifi-echo/server/esp32/main/EchoDeviceCallbacks.cpp @@ -31,6 +31,11 @@ #include "LEDWidget.h" #include +extern "C" { +#include "gen/attribute-id.h" +#include "gen/cluster-id.h" +} // extern "C" + static const char * TAG = "echo-devicecallbacks"; using namespace ::chip::Inet; using namespace ::chip::DeviceLayer; @@ -70,17 +75,17 @@ void EchoDeviceCallbacks::DeviceEventCallback(const ChipDeviceEvent * event, int } } -void EchoDeviceCallbacks::PostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, +void EchoDeviceCallbacks::PostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) { - if (clusterId != CHIP_ZCL_CLUSTER_ON_OFF) + if (clusterId != ZCL_ON_OFF_CLUSTER_ID) { ESP_LOGI(TAG, "Unknown cluster ID: %d", clusterId); return; } - if (attributeId != CHIP_ZCL_CLUSTER_ON_OFF_SERVER_ATTRIBUTE_ON_OFF) + if (attributeId != ZCL_ON_OFF_ATTRIBUTE_ID) { ESP_LOGI(TAG, "Unknown attribute ID: %d", attributeId); return; diff --git a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c index 6d5b53ebdafcf4..952e0db0a16e73 100644 --- a/examples/wifi-echo/server/esp32/main/gen/callback-stub.c +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -1794,6 +1794,9 @@ int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t chann return emberAfMaxPowerLevel(); } +// Ifdef out the attribute change callback, since we implement it in +// DataModelHandler +#if 0 /** @brief Post Attribute Change * * This function is called by the application framework after it changes an @@ -1812,6 +1815,7 @@ int8_t emberAfPluginNetworkSteeringGetPowerForRadioChannelCallback(uint8_t chann void emberAfPostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) {} +#endif /** @brief Post Em4 Reset * @@ -2278,6 +2282,9 @@ void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, uint8_t over */ void emberAfSetTimeCallback(uint32_t utcTime) {} +// Ifdef out emberAfOnOffClusterSetValueCallback, since it's implemented by +// on-off.c +#if 0 /** @brief On/off Cluster Set Value * * This function is called when the on/off value needs to be set, either through @@ -2291,6 +2298,7 @@ EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t comm { return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; } +#endif /** @brief Set Wake Timeout Bitmask * diff --git a/examples/wifi-echo/server/esp32/main/include/CHIPDeviceManager.h b/examples/wifi-echo/server/esp32/main/include/CHIPDeviceManager.h index b05ceae259e513..ece93af7278cd2 100644 --- a/examples/wifi-echo/server/esp32/main/include/CHIPDeviceManager.h +++ b/examples/wifi-echo/server/esp32/main/include/CHIPDeviceManager.h @@ -37,10 +37,8 @@ #include extern "C" { -#include "chip-zcl/chip-zcl.h" -#include "gen/gen-cluster-id.h" -#include "gen/gen-types.h" -} +#include "../af-types.h" +} // extern "C" namespace chip { namespace DeviceManager { @@ -77,7 +75,7 @@ class DLL_EXPORT CHIPDeviceManagerCallbacks * @param size size of the attribute * @param value pointer to the new value */ - virtual void PostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, + virtual void PostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) {} virtual ~CHIPDeviceManagerCallbacks() {} diff --git a/examples/wifi-echo/server/esp32/main/include/EchoDeviceCallbacks.h b/examples/wifi-echo/server/esp32/main/include/EchoDeviceCallbacks.h index 2386b900fc28ce..00e611ee60b540 100644 --- a/examples/wifi-echo/server/esp32/main/include/EchoDeviceCallbacks.h +++ b/examples/wifi-echo/server/esp32/main/include/EchoDeviceCallbacks.h @@ -34,7 +34,7 @@ class EchoDeviceCallbacks : public CHIPDeviceManagerCallbacks { public: virtual void DeviceEventCallback(const chip::DeviceLayer::ChipDeviceEvent * event, intptr_t arg); - virtual void PostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, + virtual void PostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value); }; diff --git a/examples/wifi-echo/server/esp32/main/types_stub.h b/examples/wifi-echo/server/esp32/main/types_stub.h index cd214ea3a8c881..1439df3fc45c8c 100644 --- a/examples/wifi-echo/server/esp32/main/types_stub.h +++ b/examples/wifi-echo/server/esp32/main/types_stub.h @@ -44,6 +44,8 @@ #include // For mem* functions. +#include "chip-zcl/chip-zcl-zpro-codec.h" // For EmberApsFrame + /** * @brief Defines binding types. */ @@ -238,28 +240,6 @@ enum EMBER_APS_OPTION_FRAGMENT = 0x8000 }; -/** @brief An in-memory representation of a ZigBee APS frame - * of an incoming or outgoing message. - */ -typedef struct -{ - /** The application profile ID that describes the format of the message. */ - uint16_t profileId; - /** The cluster ID for this message. */ - uint16_t clusterId; - /** The source endpoint. */ - uint8_t sourceEndpoint; - /** The destination endpoint. */ - uint8_t destinationEndpoint; - /** A bitmask of options from the enumeration above. */ - EmberApsOption options; - /** The group ID for this message, if it is multicast mode. */ - uint16_t groupId; - /** The sequence number. */ - uint8_t sequence; - uint8_t radius; -} EmberApsFrame; - /** * @brief Size of EUI64 (an IEEE address) in bytes (8). */ diff --git a/src/app/DataModel.am b/src/app/DataModel.am index eda008cc3f5546..1b117d83517530 100644 --- a/src/app/DataModel.am +++ b/src/app/DataModel.am @@ -24,7 +24,7 @@ # must be anchored relative to the top build directory. # -CHIP_BUILD_DATA_MODEL_SOURCE_FILES = \ +CHIP_BUILD_OLD_DATA_MODEL_SOURCE_FILES = \ @top_builddir@/src/app/gen/gen-callback-stubs.c \ @top_builddir@/src/app/gen/gen-command-handler.c \ @top_builddir@/src/app/gen/gen-global-command-handler.c \ @@ -38,6 +38,9 @@ CHIP_BUILD_DATA_MODEL_SOURCE_FILES @top_builddir@/src/app/plugin/core-api/core-api.c \ @top_builddir@/src/app/plugin/core-data-model/zcl-data-model.c \ @top_builddir@/src/app/plugin/core-message-dispatch/dispatch.c \ + $(NULL) + +CHIP_BUILD_DATA_MODEL_SOURCE_FILES = \ @top_builddir@/src/app/chip-zcl-zpro/command-encoder/encoder.c \ @top_builddir@/src/app/chip-zcl-zpro/command-encoder/decoder.c \ $(NULL) diff --git a/src/app/Makefile.am b/src/app/Makefile.am index 4a2f52f51a9e41..dadf5c2acada5e 100644 --- a/src/app/Makefile.am +++ b/src/app/Makefile.am @@ -41,6 +41,9 @@ libCHIPDataModel_a_CPPFLAGS = \ -I$(top_srcdir)/src/lib \ $(NULL) -libCHIPDataModel_a_SOURCES = $(CHIP_BUILD_DATA_MODEL_SOURCE_FILES) +libCHIPDataModel_a_SOURCES = \ + $(CHIP_BUILD_DATA_MODEL_SOURCE_FILES) \ + $(CHIP_BUILD_OLD_DATA_MODEL_SOURCE_FILES) \ + $(NULL) include $(abs_top_nlbuild_autotools_dir)/automake/post.am From 9c79b6c7fda6562b9b136aa2aeee4b148540ea94 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 9 Jul 2020 15:24:33 -0400 Subject: [PATCH 11/12] Switch command-line chip-tool to using the new On/Off implementation. --- examples/chip-tool/main.cpp | 52 +++++++++++-------------------------- 1 file changed, 15 insertions(+), 37 deletions(-) diff --git a/examples/chip-tool/main.cpp b/examples/chip-tool/main.cpp index 4165855e5d32ac..0453d4be81962c 100644 --- a/examples/chip-tool/main.cpp +++ b/examples/chip-tool/main.cpp @@ -40,11 +40,10 @@ extern "C" { #include "chip-zcl/chip-zcl.h" -#include "gen/gen-cluster-id.h" -#include "gen/gen-command-id.h" -#include "gen/gen-types.h" } // extern "C" +#include "chip-zcl/chip-zcl-zpro-codec.h" + // Delay, in seconds, between sends for the echo case. #define SEND_DELAY 5 @@ -202,7 +201,7 @@ bool DetermineCommand(int argc, char * argv[], Command * command) union CommandArgs { - ChipZclEndpointId_t endpointId; + uint8_t endpointId; }; bool DetermineCommandArgs(int argc, char * argv[], Command command, CommandArgs * commandArgs) @@ -266,51 +265,37 @@ void DoEcho(DeviceController::ChipDeviceController * controller, const IPAddress // Handle the on/off/toggle case, where we are sending a ZCL command and not // expecting a response at all. -void DoOnOff(DeviceController::ChipDeviceController * controller, Command command, ChipZclEndpointId_t endpoint) +void DoOnOff(DeviceController::ChipDeviceController * controller, Command command, uint8_t endpoint) { - ChipZclCommandId_t zclCommand; + // Make sure our buffer is big enough, but this will need a better setup! + static const size_t bufferSize = 1024; + auto * buffer = System::PacketBuffer::NewWithAvailableSize(bufferSize); + + uint16_t dataLength = 0; switch (command) { case Command::Off: - zclCommand = CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_OFF; + dataLength = encodeOffCommand(buffer->Start(), bufferSize, endpoint); break; case Command::On: - zclCommand = CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_ON; + dataLength = encodeOnCommand(buffer->Start(), bufferSize, endpoint); break; case Command::Toggle: - zclCommand = CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_TOGGLE; + dataLength = encodeToggleCommand(buffer->Start(), bufferSize, endpoint); break; default: fprintf(stderr, "Unknown command: %d\n", command); return; } - - // Make sure our buffer is big enough, but this will need a better setup! - static const size_t bufferSize = 1024; - auto * buffer = System::PacketBuffer::NewWithAvailableSize(bufferSize); - - ChipZclBuffer_t * zcl_buffer = (ChipZclBuffer_t *) buffer; - ChipZclCommandContext_t ctx = { - endpoint, // endpointId - CHIP_ZCL_CLUSTER_ON_OFF, // clusterId - true, // clusterSpecific - false, // mfgSpecific - 0, // mfgCode - zclCommand, // commandId - ZCL_DIRECTION_CLIENT_TO_SERVER, // direction - 0, // payloadStartIndex - nullptr, // request - nullptr // response - }; - chipZclEncodeZclHeader(zcl_buffer, &ctx); + buffer->SetDataLength(dataLength); #ifdef DEBUG - const size_t data_len = chipZclBufferDataLength(zcl_buffer); + const size_t data_len = buffer->DataLength(); fprintf(stderr, "SENDING: %zu ", data_len); for (size_t i = 0; i < data_len; ++i) { - fprintf(stderr, "%d ", chipZclBufferPointer(zcl_buffer)[i]); + fprintf(stderr, "%d ", buffer->Start()[i]); } fprintf(stderr, "\n"); #endif @@ -362,10 +347,3 @@ int main(int argc, char * argv[]) return (err == CHIP_NO_ERROR) ? EXIT_SUCCESS : EXIT_FAILURE; } - -extern "C" { -// We have to have this empty callback, because the ZCL code links against it. -void chipZclPostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, uint8_t mask, - uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) -{} -} // extern "C" From b83d48957f0978736b750f666f898e05c15a80de Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Tue, 14 Jul 2020 23:52:24 -0400 Subject: [PATCH 12/12] Switch iOS CHIPTool to using the new On/Off implementation. --- .../Framework/CHIP/CHIPDeviceController.h | 6 +- .../Framework/CHIP/CHIPDeviceController.mm | 60 +++++++++---------- src/darwin/Framework/CHIP/CHIPOnOff.mm | 12 +--- 3 files changed, 34 insertions(+), 44 deletions(-) diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.h b/src/darwin/Framework/CHIP/CHIPDeviceController.h index aec702d775b638..d9b1c358809f75 100644 --- a/src/darwin/Framework/CHIP/CHIPDeviceController.h +++ b/src/darwin/Framework/CHIP/CHIPDeviceController.h @@ -41,9 +41,9 @@ typedef void (^ControllerOnErrorBlock)(NSError * error); error:(NSError * __autoreleasing *)error; - (nullable AddressInfo *)getAddressInfo; - (BOOL)sendMessage:(NSData *)message error:(NSError * __autoreleasing *)error; -// We can't include definitions of ChipZclClusterId_t and ChipZclCommandId_t -// here, but they're just integers, so pass them that way. -- (BOOL)sendCHIPCommand:(uint16_t)cluster command:(uint16_t)command; +- (BOOL)sendOnCommand; +- (BOOL)sendOffCommand; +- (BOOL)sendToggleCommand; - (BOOL)disconnect:(NSError * __autoreleasing *)error; - (BOOL)isConnected; diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.mm b/src/darwin/Framework/CHIP/CHIPDeviceController.mm index 38236d0338a797..339b4710b9febe 100644 --- a/src/darwin/Framework/CHIP/CHIPDeviceController.mm +++ b/src/darwin/Framework/CHIP/CHIPDeviceController.mm @@ -17,11 +17,7 @@ #import -extern "C" { -#include "chip-zcl/chip-zcl-buffer.h" -#include "chip-zcl/chip-zcl.h" -#include "gen/gen-command-id.h" -} // extern "C" +#include "chip-zcl/chip-zcl-zpro-codec.h" #import "CHIPDeviceController.h" #import "CHIPError.h" @@ -261,7 +257,7 @@ - (BOOL)sendMessage:(NSData *)message error:(NSError * __autoreleasing *)error return YES; } -- (BOOL)sendCHIPCommand:(ChipZclClusterId_t)cluster command:(ChipZclCommandId_t)command +- (BOOL)sendCHIPCommand:(uint32_t (^)(chip::System::PacketBuffer *, uint16_t))encodeCommandBlock { CHIP_ERROR err = CHIP_NO_ERROR; [self.lock lock]; @@ -269,24 +265,8 @@ - (BOOL)sendCHIPCommand:(ChipZclClusterId_t)cluster command:(ChipZclCommandId_t) static const size_t bufferSize = 1024; chip::System::PacketBuffer * buffer = chip::System::PacketBuffer::NewWithAvailableSize(bufferSize); - ChipZclBuffer_t * zcl_buffer = (ChipZclBuffer_t *) buffer; - ChipZclCommandContext_t ctx = { - 1, // endpointId - cluster, // clusterId - true, // clusterSpecific - false, // mfgSpecific - 0, // mfgCode - command, // commandId - ZCL_DIRECTION_CLIENT_TO_SERVER, // direction - 0, // payloadStartIndex - nullptr, // request - nullptr // response - }; - chipZclEncodeZclHeader(zcl_buffer, &ctx); - - const size_t data_len = chipZclBufferDataLength(zcl_buffer); - - buffer->SetDataLength(data_len); + uint32_t dataLength = encodeCommandBlock(buffer, (uint16_t) bufferSize); + buffer->SetDataLength(dataLength); err = self.cppController->SendMessage((__bridge void *) self, buffer); [self.lock unlock]; @@ -297,6 +277,30 @@ - (BOOL)sendCHIPCommand:(ChipZclClusterId_t)cluster command:(ChipZclCommandId_t) return YES; } +- (BOOL)sendOnCommand +{ + return [self sendCHIPCommand:^(chip::System::PacketBuffer * buffer, uint16_t bufferSize) { + // Hardcode endpoint to 1 for now + return encodeOnCommand(buffer->Start(), bufferSize, 1); + }]; +} + +- (BOOL)sendOffCommand +{ + return [self sendCHIPCommand:^(chip::System::PacketBuffer * buffer, uint16_t bufferSize) { + // Hardcode endpoint to 1 for now + return encodeOffCommand(buffer->Start(), bufferSize, 1); + }]; +} + +- (BOOL)sendToggleCommand +{ + return [self sendCHIPCommand:^(chip::System::PacketBuffer * buffer, uint16_t bufferSize) { + // Hardcode endpoint to 1 for now + return encodeToggleCommand(buffer->Start(), bufferSize, 1); + }]; +} + - (BOOL)disconnect:(NSError * __autoreleasing *)error { CHIP_ERROR err = CHIP_NO_ERROR; @@ -360,11 +364,3 @@ - (void)registerCallbacks:appCallbackQueue onMessage:(ControllerOnMessageBlock)o } @end - -extern "C" { -// We have to have this empty callback, because the ZCL code links against it. -void chipZclPostAttributeChangeCallback(uint8_t endpoint, ChipZclClusterId clusterId, ChipZclAttributeId attributeId, uint8_t mask, - uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value) -{ -} -} // extern "C" diff --git a/src/darwin/Framework/CHIP/CHIPOnOff.mm b/src/darwin/Framework/CHIP/CHIPOnOff.mm index cca829b6693fe1..ff854a783da95d 100644 --- a/src/darwin/Framework/CHIP/CHIPOnOff.mm +++ b/src/darwin/Framework/CHIP/CHIPOnOff.mm @@ -19,12 +19,6 @@ #import "CHIPOnOff.h" -extern "C" { -#include "chip-zcl/chip-zcl.h" -#include "gen/gen-cluster-id.h" -#include "gen/gen-types.h" -} - @interface CHIPOnOff () @property (readonly) CHIPDeviceController * deviceController; @@ -43,17 +37,17 @@ - (instancetype)initWithDeviceController:(CHIPDeviceController *)deviceControlle - (BOOL)lightOn { - return [self.deviceController sendCHIPCommand:CHIP_ZCL_CLUSTER_ON_OFF command:CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_ON]; + return [self.deviceController sendOnCommand]; } - (BOOL)lightOff { - return [self.deviceController sendCHIPCommand:CHIP_ZCL_CLUSTER_ON_OFF command:CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_OFF]; + return [self.deviceController sendOffCommand]; } - (BOOL)toggleLight { - return [self.deviceController sendCHIPCommand:CHIP_ZCL_CLUSTER_ON_OFF command:CHIP_ZCL_CLUSTER_ON_OFF_SERVER_COMMAND_TOGGLE]; + return [self.deviceController sendToggleCommand]; } @end