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/configure.ac b/configure.ac index 5ac4a29a976a48..c2f3c019e1a973 100644 --- a/configure.ac +++ b/configure.ac @@ -2333,6 +2333,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/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" 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/af-main.h b/examples/wifi-echo/server/esp32/main/af-main.h new file mode 100644 index 00000000000000..20ea4cfa18f23f --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af-main.h @@ -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. + */ + +/** + * + * 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 "af-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 + +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..5b1c6a464ee20e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af-types.h @@ -0,0 +1,1976 @@ +/** + * + * 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 // For bool +#include // For NULL. +#include // For various uint*_t types + +#include "gen/enums.h" +#include "types_stub.h" // For various types. + +#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..924efa8d7b86e0 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/af.h @@ -0,0 +1,1900 @@ +/** + * + * 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 "config.h" +#endif +#include CONFIGURATION_HEADER + +#ifdef EZSP_HOST +// Includes needed for ember related functions for the EZSP host +#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" +#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 "client-api.h" +#include "gen/af-structs.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" +#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 "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..19ddbc3a2f8480 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-size.c @@ -0,0 +1,97 @@ +/** + * + * 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 "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]; + } + } + + 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..a932931db40534 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.c @@ -0,0 +1,1301 @@ +/** + * + * 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 "attribute-storage.h" +#include "af.h" +#include "common.h" + +#include "gen/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 = 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; + } + } + 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..0f550250f3730b --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-storage.h @@ -0,0 +1,224 @@ +/** + * + * 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 "af.h" + +#if !defined(EMBER_SCRIPTED_TEST) +#include "gen/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." +#include "gen/endpoint_config.h" +#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..ede422b07abd4a --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-table.c @@ -0,0 +1,659 @@ +/** + * + * 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 "gen/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..0b6927cf50f302 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/attribute-table.h @@ -0,0 +1,71 @@ +/** + * + * 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 "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..4853b0d3fdc9b5 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/client-api.h @@ -0,0 +1,180 @@ +/** + * + * 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 "gen/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..b69ef0e5174e94 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/common.h @@ -0,0 +1,58 @@ +/** + * + * 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 "af.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 uint16_t appResponseLength; +extern EmberNodeId emberAfResponseDestination; + +#endif // SILABS_COMMON_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/config.h b/examples/wifi-echo/server/esp32/main/config.h new file mode 100644 index 00000000000000..5a45e5384b685e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/config.h @@ -0,0 +1,303 @@ +/** + * + * 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 +#else +#include "gen/gen_config.h" +#endif + +#ifdef ATTRIBUTE_STORAGE_CONFIGURATION +#include ATTRIBUTE_STORAGE_CONFIGURATION +#else +#include "gen/endpoint_config.h" +#endif + +#include "gen/gen_tokens.h" // For GENERATED_TOKEN_LOADER/SAVER macros + +// ******************************************************************* +// 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/gen/af-structs.h b/examples/wifi-echo/server/esp32/main/gen/af-structs.h new file mode 100644 index 00000000000000..8009281c7692c6 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/af-structs.h @@ -0,0 +1,458 @@ +/** + * + * 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..40a1a0088b4872 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/att-storage.h @@ -0,0 +1,87 @@ +/** + * + * 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..442f72e97e2232 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-id.h @@ -0,0 +1,4786 @@ +/** + * + * 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..8ab0dae3944631 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/attribute-size.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_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..35879dabb2ed6e --- /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..c3753adcd622f4 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.c @@ -0,0 +1,143 @@ +/** + * + * 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 "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-types.h" +#include "stack/include/error.h" +#else +// Includes needed for ember related functions for the EM250 +// #include "stack/include/ember.h" +#endif // EZSP_HOST + +#include + +#include "../util.h" +#include "af-structs.h" +#include "call-command-handler.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; + } +} + +// 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..c1019c157ed9fd --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/call-command-handler.h @@ -0,0 +1,48 @@ +/** + * + * 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..952e0db0a16e73 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/callback-stub.c @@ -0,0 +1,2477 @@ +/** + * + * 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 "../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 + * 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(); +} + +// 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 + * 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) +{} +#endif + +/** @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) {} + +// 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 + * 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; +} +#endif + +/** @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..61b29baad88c7a --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/callback.h @@ -0,0 +1,23777 @@ +/** + * + * 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 "../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); +/** @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 */ + +/** @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..95d50f8f679b7e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/client-command-macro.h @@ -0,0 +1,8927 @@ +/** + * + * 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..7462d4e9cf279b --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/cluster-id.h @@ -0,0 +1,174 @@ +/** + * + * 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..823914d0466035 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/command-id.h @@ -0,0 +1,1037 @@ +/** + * + * 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..4eab0f0afc9fcc --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/debug-printing.h @@ -0,0 +1,2939 @@ +/** + * + * 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..70c37bde9d2ec9 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/endpoint_config.h @@ -0,0 +1,160 @@ +/** + * + * 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..c1881b3732b9e3 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/enums.h @@ -0,0 +1,3570 @@ +/** + * + * 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..bd3bf01cb8c1cd --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/gen_config.h @@ -0,0 +1,282 @@ +/** + * + * 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..80bd8a4098e676 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/gen_tokens.h @@ -0,0 +1,60 @@ +/** + * + * 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..87d2771f942629 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/print-cluster.h @@ -0,0 +1,778 @@ +/** + * + * 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..4aa0e414883c13 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/gen/znet-bookkeeping.c @@ -0,0 +1,122 @@ +/** + * + * 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..1fafa460393ba9 --- /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 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/message.c b/examples/wifi-echo/server/esp32/main/message.c new file mode 100644 index 00000000000000..78b9c669520d05 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/message.c @@ -0,0 +1,286 @@ +/** + * + * 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 "af.h" +#include "config.h" +#include "util.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 = 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; +} + +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..6cb40455ab055e --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/on-off.c @@ -0,0 +1,277 @@ +/** + * + * 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..21444a2faccc2b --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/process-cluster-message.c @@ -0,0 +1,112 @@ +/** + * + * 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..642fd1c34a4651 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/process-global-message.c @@ -0,0 +1,704 @@ +/** + * + * 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 "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 "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" +#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..26c9fa4e080308 --- /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..1439df3fc45c8c --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/types_stub.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 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 + ******************************************************************************/ + +#ifndef TYPES_STUB_H +#define TYPES_STUB_H + +#include // For mem* functions. + +#include "chip-zcl/chip-zcl-zpro-codec.h" // For EmberApsFrame + +/** + * @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 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). + */ +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 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; + +#ifdef DOXYGEN_SHOULD_SKIP_THIS +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 +typedef uint8_t EmberStatus; +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 11 + +/** + * @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 + +// 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 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..8f9f5a08eeba86 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/util.c @@ -0,0 +1,1411 @@ +/** + * + * 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 "af-main.h" +#include "af.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 "gen/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++) + { + // FIXME: Do we need to support more than one network? + // emberAfPushNetworkIndex(i); + emberAfInitializeAttributes(EMBER_BROADCAST_ENDPOINT); + // 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(); + +#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 (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(); +} + +// **************************************** +// 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'; +#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", 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 && false /*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++) + { + // Crash so we don't reach this code by accident. + *(int *) 0 = 5; + // 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..c87ddeddef0b96 --- /dev/null +++ b/examples/wifi-echo/server/esp32/main/util.h @@ -0,0 +1,306 @@ +/** + * + * 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 "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__ 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..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 \ @@ -40,6 +40,11 @@ CHIP_BUILD_DATA_MODEL_SOURCE_FILES @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) + # Excluding this one for now because it has #include syntax that does # not actually compile # plugin/core-data-model/zcl-struct.c diff --git a/src/app/Makefile.am b/src/app/Makefile.am index 2dc0aadd146a59..dadf5c2acada5e 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) @@ -40,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 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); +} 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